home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / MacPNG Library 1.02 / pngMacSrc 1.02 / PNG Library 0.80 / PNGRTRAN.C < prev    next >
Text File  |  1996-05-29  |  93KB  |  2,921 lines
  1.  
  2. /* pngrtran.c - transforms the data in a row for png readers
  3.  
  4.    libpng 1.0 beta 2 - version 0.8
  5.    For conditions of distribution and use, see copyright notice in png.h
  6.    Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
  7.    August 20, 1995
  8.    */
  9.  
  10. #define PNG_INTERNAL
  11. #include "png.h"
  12.  
  13. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  14. /* handle alpha and tRNS via a background color */
  15. void
  16. png_set_background(png_struct *png_ptr,
  17.    png_color_16 *background_color, int background_gamma_code,
  18.    int need_expand, double background_gamma)
  19. {
  20.    png_ptr->transformations |= PNG_BACKGROUND;
  21.    memcpy(&(png_ptr->background), background_color,
  22.       sizeof(png_color_16));
  23.    png_ptr->background_gamma = (float)background_gamma;
  24.    png_ptr->background_gamma_type = background_gamma_code;
  25.    png_ptr->background_expand = need_expand;
  26. }
  27. #endif
  28.  
  29. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  30. /* strip 16 bit depth files to 8 bit depth */
  31. void
  32. png_set_strip_16(png_struct *png_ptr)
  33. {
  34.    png_ptr->transformations |= PNG_16_TO_8;
  35. }
  36. #endif
  37.  
  38. #if defined(PNG_READ_DITHER_SUPPORTED)
  39. /* dither file to 8 bit.  Supply a palette, the current number
  40.    of elements in the palette, the maximum number of elements
  41.    allowed, and a histogram, if possible.  If the current number
  42.    is greater then the maximum number, the palette will be
  43.    modified to fit in the maximum number */
  44.  
  45. typedef struct dsort_struct
  46. {
  47.    struct dsort_struct *next;
  48.    png_byte left;
  49.    png_byte right;
  50. } dsort;
  51.  
  52. void
  53. png_set_dither(png_struct *png_ptr, png_color *palette,
  54.    int num_palette, int maximum_colors, png_uint_16 *histogram,
  55.    int full_dither)
  56. {
  57.    png_ptr->transformations |= PNG_DITHER;
  58.  
  59.    if (!full_dither)
  60.    {
  61.       int i;
  62.  
  63.       png_ptr->dither_index = png_malloc(png_ptr,
  64.          num_palette * sizeof (png_byte));
  65.       for (i = 0; i < num_palette; i++)
  66.          png_ptr->dither_index[i] = i;
  67.    }
  68.  
  69.    if (num_palette > maximum_colors)
  70.    {
  71.       if (histogram)
  72.       {
  73.          /* this is easy enough, just throw out the least used colors.
  74.             perhaps not the best solution, but good enough */
  75.  
  76.          int i;
  77.          png_byte *sort;
  78.  
  79.          /* initialize an array to sort colors */
  80.          sort = (png_byte *)png_malloc(png_ptr, num_palette * sizeof (png_byte));
  81.  
  82.          /* initialize the sort array */
  83.          for (i = 0; i < num_palette; i++)
  84.             sort[i] = i;
  85.  
  86.          /* find the least used palette entries by starting a
  87.             bubble sort, and running it until we have sorted
  88.             out enough colors.  Note that we don't care about
  89.             sorting all the colors, just finding which are
  90.             least used. */
  91.  
  92.          for (i = num_palette - 1; i >= maximum_colors; i--)
  93.          {
  94.             int done; /* to stop early if the list is pre-sorted */
  95.             int j;
  96.  
  97.             done = 1;
  98.             for (j = 0; j < i; j++)
  99.             {
  100.                if (histogram[sort[j]] < histogram[sort[j + 1]])
  101.                {
  102.                   png_byte t;
  103.  
  104.                   t = sort[j];
  105.                   sort[j] = sort[j + 1];
  106.                   sort[j + 1] = t;
  107.                   done = 0;
  108.                }
  109.             }
  110.             if (done)
  111.                break;
  112.          }
  113.  
  114.          /* swap the palette around, and set up a table, if necessary */
  115.          if (full_dither)
  116.          {
  117.             int j;
  118.  
  119.             /* put all the useful colors within the max, but don't
  120.                move the others */
  121.             j = num_palette;
  122.             for (i = 0; i < maximum_colors; i++)
  123.             {
  124.                if (sort[i] >= maximum_colors)
  125.                {
  126.                   do
  127.                      j--;
  128.                   while (sort[j] >= maximum_colors);
  129.                   palette[i] = palette[j];
  130.                }
  131.             }
  132.          }
  133.          else
  134.          {
  135.             int j;
  136.  
  137.             /* move all the used colors inside the max limit, and
  138.                develop a translation table */
  139.             j = num_palette;
  140.             for (i = 0; i < maximum_colors; i++)
  141.             {
  142.                /* only move the colors we need to */
  143.                if (sort[i] >= maximum_colors)
  144.                {
  145.                   png_color tmp_color;
  146.  
  147.                   do
  148.                      j--;
  149.                   while (sort[j] >= maximum_colors);
  150.  
  151.                   tmp_color = palette[j];
  152.                   palette[j] = palette[i];
  153.                   palette[i] = tmp_color;
  154.                   /* indicate where the color went */
  155.                   png_ptr->dither_index[j] = i;
  156.                   png_ptr->dither_index[i] = j;
  157.                }
  158.             }
  159.             /* find closest color for those colors we are not
  160.                using */
  161.             for (i = 0; i < num_palette; i++)
  162.             {
  163.                if (png_ptr->dither_index[i] >= maximum_colors)
  164.                {
  165.                   int min_d, j, min_j, index;
  166.  
  167.                   /* find the closest color to one we threw out */
  168.                   index = png_ptr->dither_index[i];
  169.                   min_d = PNG_COLOR_DIST(palette[index],
  170.                         palette[0]);
  171.                   min_j = 0;
  172.                   for (j = 1; j < maximum_colors; j++)
  173.                   {
  174.                      int d;
  175.  
  176.                      d = PNG_COLOR_DIST(palette[index],
  177.                         palette[j]);
  178.  
  179.                      if (d < min_d)
  180.                      {
  181.                         min_d = d;
  182.                         min_j = j;
  183.                      }
  184.                   }
  185.                   /* point to closest color */
  186.                   png_ptr->dither_index[i] = min_j;
  187.                }
  188.             }
  189.          }
  190.          png_free(png_ptr, sort);
  191.       }
  192.       else
  193.       {
  194.          /* this is much harder to do simply (and quickly).  Perhaps
  195.             we need to go through a median cut routine, but those
  196.             don't always behave themselves with only a few colors
  197.             as input.  So we will just find the closest two colors,
  198.             and throw out one of them (chosen somewhat randomly).
  199.             */
  200.          int i;
  201.          int max_d;
  202.          int num_new_palette;
  203.          dsort **hash;
  204.          png_byte *index_to_palette;
  205.             /* where the original index currently is in the palette */
  206.          png_byte *palette_to_index;
  207.             /* which original index points to this palette color */
  208.  
  209.          /* initialize palette index arrays */
  210.          index_to_palette = (png_byte *)png_malloc(png_ptr,
  211.             num_palette * sizeof (png_byte));
  212.          palette_to_index = (png_byte *)png_malloc(png_ptr,
  213.             num_palette * sizeof (png_byte));
  214.  
  215.          /* initialize the sort array */
  216.          for (i = 0; i < num_palette; i++)
  217.          {
  218.             index_to_palette[i] = i;
  219.             palette_to_index[i] = i;
  220.          }
  221.  
  222.          hash = (dsort **)png_malloc(png_ptr, 769 * sizeof (dsort *));
  223.          for (i = 0; i < 769; i++)
  224.             hash[i] = (dsort *)0;
  225. /*         memset(hash, 0, 769 * sizeof (dsort *)); */
  226.  
  227.          num_new_palette = num_palette;
  228.  
  229.          /* initial wild guess at how far apart the farthest pixel
  230.             pair we will be eliminating will be.  Larger
  231.             numbers mean more areas will be allocated, Smaller
  232.             numbers run the risk of not saving enough data, and
  233.             having to do this all over again.
  234.  
  235.             I have not done extensive checking on this number.
  236.             */
  237.          max_d = 96;
  238.  
  239.          while (num_new_palette > maximum_colors)
  240.          {
  241.             for (i = 0; i < num_new_palette - 1; i++)
  242.             {
  243.                int j;
  244.  
  245.                for (j = i + 1; j < num_new_palette; j++)
  246.                {
  247.                   int d;
  248.  
  249.                   d = PNG_COLOR_DIST(palette[i], palette[j]);
  250.  
  251.                   if (d <= max_d)
  252.                   {
  253.                      dsort *t;
  254.  
  255.                      t = png_malloc(png_ptr, sizeof (dsort));
  256.                      t->next = hash[d];
  257.                      t->left = i;
  258.                      t->right = j;
  259.                      hash[d] = t;
  260.                   }
  261.                }
  262.             }
  263.  
  264.             for (i = 0; i <= max_d; i++)
  265.             {
  266.                if (hash[i])
  267.                {
  268.                   dsort *p;
  269.  
  270.                   for (p = hash[i]; p; p = p->next)
  271.                   {
  272.                      if (index_to_palette[p->left] < num_new_palette &&
  273.                         index_to_palette[p->right] < num_new_palette)
  274.                      {
  275.                         int j, next_j;
  276.  
  277.                         if (num_new_palette & 1)
  278.                         {
  279.                            j = p->left;
  280.                            next_j = p->right;
  281.                         }
  282.                         else
  283.                         {
  284.                            j = p->right;
  285.                            next_j = p->left;
  286.                         }
  287.  
  288.                         num_new_palette--;
  289.                         palette[index_to_palette[j]] =
  290.                            palette[num_new_palette];
  291.                         if (!full_dither)
  292.                         {
  293.                            int k;
  294.  
  295.                            for (k = 0; k < num_palette; k++)
  296.                            {
  297.                               if (png_ptr->dither_index[k] ==
  298.                                  index_to_palette[j])
  299.                                  png_ptr->dither_index[k] =
  300.                                     index_to_palette[next_j];
  301.                               if (png_ptr->dither_index[k] ==
  302.                                  num_new_palette)
  303.                                  png_ptr->dither_index[k] =
  304.                                     index_to_palette[j];
  305.                            }
  306.                         }
  307.  
  308.                         index_to_palette[palette_to_index[num_new_palette]] =
  309.                            index_to_palette[j];
  310.                         palette_to_index[index_to_palette[j]] =
  311.                            palette_to_index[num_new_palette];
  312.  
  313.                         index_to_palette[j] = num_new_palette;
  314.                         palette_to_index[num_new_palette] = j;
  315.                      }
  316.                      if (num_new_palette <= maximum_colors)
  317.                         break;
  318.                   }
  319.                   if (num_new_palette <= maximum_colors)
  320.                      break;
  321.                }
  322.             }
  323.  
  324.             for (i = 0; i < 769; i++)
  325.             {
  326.                if (hash[i])
  327.                {
  328.                   dsort *p;
  329.  
  330.                   p = hash[i];
  331.                   while (p)
  332.                   {
  333.                      dsort *t;
  334.  
  335.                      t = p->next;
  336.                      png_free(png_ptr, p);
  337.                      p = t;
  338.                   }
  339.                }
  340.                hash[i] = 0;
  341.             }
  342.             max_d += 96;
  343.          }
  344.          png_free(png_ptr, hash);
  345.          png_free(png_ptr, palette_to_index);
  346.          png_free(png_ptr, index_to_palette);
  347.       }
  348.       num_palette = maximum_colors;
  349.    }
  350.    if (!(png_ptr->palette))
  351.    {
  352.       png_ptr->palette = palette;
  353.       png_ptr->user_palette = 1;
  354.    }
  355.    png_ptr->num_palette = num_palette;
  356.  
  357.    if (full_dither)
  358.    {
  359.       int i;
  360.       int total_bits, num_red, num_green, num_blue;
  361.       png_uint_32 num_entries;
  362.       png_byte *distance;
  363.  
  364.       total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
  365.          PNG_DITHER_BLUE_BITS;
  366.  
  367.       num_red = (1 << PNG_DITHER_RED_BITS);
  368.       num_green = (1 << PNG_DITHER_GREEN_BITS);
  369.       num_blue = (1 << PNG_DITHER_BLUE_BITS);
  370.       num_entries = ((png_uint_32)1 << total_bits);
  371.  
  372.       png_ptr->palette_lookup = (png_byte *)png_large_malloc(png_ptr,
  373.          (png_size_t)num_entries * sizeof (png_byte));
  374.  
  375.       memset(png_ptr->palette_lookup, 0, (png_size_t)num_entries * sizeof (png_byte));
  376.  
  377.       distance = (png_byte *)png_large_malloc(png_ptr,
  378.          (png_size_t)num_entries * sizeof (png_byte));
  379.  
  380.       memset(distance, 0xff, (png_size_t)num_entries * sizeof (png_byte));
  381.  
  382.       for (i = 0; i < num_palette; i++)
  383.       {
  384.          int r, g, b, ir, ig, ib;
  385.  
  386.          r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
  387.          g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
  388.          b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
  389.  
  390.          for (ir = 0; ir < num_red; ir++)
  391.          {
  392.             int dr, index_r;
  393.  
  394.             dr = abs(ir - r);
  395.             index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
  396.             for (ig = 0; ig < num_green; ig++)
  397.             {
  398.                int dg, dt, dm, index_g;
  399.  
  400.                dg = abs(ig - g);
  401.                dt = dr + dg;
  402.                dm = ((dr > dg) ? dr : dg);
  403.                index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);
  404.                for (ib = 0; ib < num_blue; ib++)
  405.                {
  406.                   int index, db, dmax, d;
  407.  
  408.                   index = index_g | ib;
  409.                   db = abs(ib - b);
  410.                   dmax = ((dm > db) ? dm : db);
  411.                   d = dmax + dt + db;
  412.  
  413.                   if (d < distance[index])
  414.                   {
  415.                      distance[index] = d;
  416.                      png_ptr->palette_lookup[index] = i;
  417.                   }
  418.                }
  419.             }
  420.          }
  421.       }
  422.  
  423.       png_large_free(png_ptr, distance);
  424.    }
  425. }
  426. #endif
  427.  
  428. #if defined(PNG_READ_GAMMA_SUPPORTED)
  429. /* transform the image from the file_gamma to the screen_gamma */
  430. void
  431. png_set_gamma(png_struct *png_ptr, double screen_gamma,
  432.    double file_gamma)
  433. {
  434.    png_ptr->transformations |= PNG_GAMMA;
  435.    png_ptr->gamma = (float)file_gamma;
  436.    png_ptr->display_gamma = (float)screen_gamma;
  437. }
  438. #endif
  439.  
  440. #if defined(PNG_READ_EXPAND_SUPPORTED)
  441. /* expand paletted images to rgb, expand grayscale images of
  442.    less then 8 bit depth to 8 bit depth, and expand tRNS chunks
  443.    to alpha channels */
  444. void
  445. png_set_expand(png_struct *png_ptr)
  446. {
  447.    png_ptr->transformations |= PNG_EXPAND;
  448. }
  449. #endif
  450.  
  451. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  452. void
  453. png_set_gray_to_rgb(png_struct *png_ptr)
  454. {
  455.    png_ptr->transformations |= PNG_GRAY_TO_RGB;
  456. }
  457. #endif
  458.  
  459. /* initialize everything needed for the read.  This includes modifying
  460.    the palette */
  461. void
  462. png_init_read_transformations(png_struct *png_ptr)
  463. {
  464.    int color_type;
  465.  
  466.    color_type = png_ptr->color_type;
  467.  
  468. #if defined(PNG_READ_EXPAND_SUPPORTED) && \
  469.     defined(PNG_READ_BACKGROUND_SUPPORTED)
  470.    if (png_ptr->transformations & PNG_EXPAND)
  471.    {
  472.       if (color_type == PNG_COLOR_TYPE_GRAY &&
  473.          png_ptr->bit_depth < 8 &&
  474.          (png_ptr->transformations & PNG_BACKGROUND) &&
  475.          png_ptr->background_expand)
  476. /*         (!(png_ptr->transformations & PNG_BACKGROUND) ||
  477.          png_ptr->background_expand)) */
  478.       {
  479.          /* expand background chunk.  While this may not be
  480.             the fastest way to do this, it only happens once
  481.             per file. */
  482.          switch (png_ptr->bit_depth)
  483.          {
  484.             case 1:
  485.                png_ptr->background.gray *= 0xff;
  486.                break;
  487.             case 2:
  488.                png_ptr->background.gray *= 0x55;
  489.                break;
  490.             case 4:
  491.                png_ptr->background.gray *= 0x11;
  492.                break;
  493.          }
  494.       }
  495.       if (color_type == PNG_COLOR_TYPE_PALETTE &&
  496.          (png_ptr->transformations & PNG_BACKGROUND) &&
  497.          png_ptr->background_expand)
  498.       {
  499.          /* expand background chunk */
  500.          png_ptr->background.red =
  501.             png_ptr->palette[png_ptr->background.index].red;
  502.          png_ptr->background.green =
  503.             png_ptr->palette[png_ptr->background.index].green;
  504.          png_ptr->background.blue =
  505.             png_ptr->palette[png_ptr->background.index].blue;
  506.          color_type = PNG_COLOR_TYPE_RGB;
  507.       }
  508.    }
  509. #endif
  510.  
  511. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  512.    png_ptr->background_1 = png_ptr->background;
  513. #endif
  514. #if defined(PNG_READ_GAMMA_SUPPORTED)
  515.    if (png_ptr->transformations & PNG_GAMMA)
  516.    {
  517.       png_build_gamma_table(png_ptr);
  518. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  519.       if ((png_ptr->transformations & PNG_BACKGROUND) &&
  520.          (color_type != PNG_COLOR_TYPE_PALETTE))
  521.       {
  522.          if (png_ptr->background_gamma_type != PNG_BACKGROUND_GAMMA_UNKNOWN)
  523.          {
  524.             double g, gs, m;
  525.  
  526.             m = (double)((png_uint_32)1 << png_ptr->bit_depth);
  527.             g = 1.0;
  528.             gs = 1.0;
  529.  
  530.             switch (png_ptr->background_gamma_type)
  531.             {
  532.                case PNG_BACKGROUND_GAMMA_SCREEN:
  533.                   g = (png_ptr->display_gamma);
  534.                   gs = 1.0;
  535.                   break;
  536.                case PNG_BACKGROUND_GAMMA_FILE:
  537.                   g = 1.0 / (png_ptr->gamma);
  538.                   gs = 1.0 / (png_ptr->gamma * png_ptr->display_gamma);
  539.                   break;
  540.                case PNG_BACKGROUND_GAMMA_UNIQUE:
  541.                   g = 1.0 / (png_ptr->background_gamma);
  542.                   gs = 1.0 / (png_ptr->background_gamma *
  543.                      png_ptr->display_gamma);
  544.                   break;
  545.             }
  546.  
  547.             if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
  548.             {
  549.                png_ptr->background_1.red = (png_uint_16)(pow(
  550.                   (double)png_ptr->background.red / m, g) * m + .5);
  551.                png_ptr->background_1.green = (png_uint_16)(pow(
  552.                   (double)png_ptr->background.green / m, g) * m + .5);
  553.                png_ptr->background_1.blue = (png_uint_16)(pow(
  554.                   (double)png_ptr->background.blue / m, g) * m + .5);
  555.                png_ptr->background.red = (png_uint_16)(pow(
  556.                   (double)png_ptr->background.red / m, gs) * m + .5);
  557.                png_ptr->background.green = (png_uint_16)(pow(
  558.                   (double)png_ptr->background.green / m, gs) * m + .5);
  559.                png_ptr->background.blue = (png_uint_16)(pow(
  560.                   (double)png_ptr->background.blue / m, gs) * m + .5);
  561.             }
  562.             else
  563.             {
  564.                png_ptr->background_1.gray = (png_uint_16)(pow(
  565.                   (double)png_ptr->background.gray / m, g) * m + .5);
  566.                png_ptr->background.gray = (png_uint_16)(pow(
  567.                   (double)png_ptr->background.gray / m, gs) * m + .5);
  568.             }
  569.          }
  570.       }
  571. #endif
  572.    }
  573. #endif
  574.  
  575. #if defined(PNG_READ_SHIFT_SUPPORTED)
  576.    if ((png_ptr->transformations & PNG_SHIFT) &&
  577.       png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  578.    {
  579.       png_uint_16 i;
  580.       int sr, sg, sb;
  581.  
  582.       sr = 8 - png_ptr->sig_bit.red;
  583.       if (sr < 0 || sr > 8)
  584.          sr = 0;
  585.       sg = 8 - png_ptr->sig_bit.green;
  586.       if (sg < 0 || sg > 8)
  587.          sg = 0;
  588.       sb = 8 - png_ptr->sig_bit.blue;
  589.       if (sb < 0 || sb > 8)
  590.          sb = 0;
  591.       for (i = 0; i < png_ptr->num_palette; i++)
  592.       {
  593.          png_ptr->palette[i].red >>= sr;
  594.          png_ptr->palette[i].green >>= sg;
  595.          png_ptr->palette[i].blue >>= sb;
  596.       }
  597.    }
  598. #endif
  599. }
  600.  
  601. /* modify the info structure to reflect the transformations.  The
  602.    info should be updated so a png file could be written with it,
  603.    assuming the transformations result in valid png data */
  604. void
  605. png_read_transform_info(png_struct *png_ptr, png_info *info_ptr)
  606. {
  607. #if defined(PNG_READ_EXPAND_SUPPORTED)
  608.    if ((png_ptr->transformations & PNG_EXPAND) &&
  609.       info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  610.    {
  611.       if (png_ptr->num_trans)
  612.          info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
  613.       else
  614.          info_ptr->color_type = PNG_COLOR_TYPE_RGB;
  615.       info_ptr->bit_depth = 8;
  616.       info_ptr->num_trans = 0;
  617.    }
  618.    else if (png_ptr->transformations & PNG_EXPAND)
  619.    {
  620.       if (png_ptr->num_trans)
  621.          info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
  622.       if (info_ptr->bit_depth < 8)
  623.          info_ptr->bit_depth = 8;
  624.       info_ptr->num_trans = 0;
  625.    }
  626. #endif
  627.  
  628. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  629.    if (png_ptr->transformations & PNG_BACKGROUND)
  630.    {
  631.       info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
  632.       info_ptr->num_trans = 0;
  633.       info_ptr->background = png_ptr->background;
  634.    }
  635. #endif
  636.  
  637. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  638.    if ((png_ptr->transformations & PNG_16_TO_8) && info_ptr->bit_depth == 16)
  639.       info_ptr->bit_depth = 8;
  640. #endif
  641.  
  642. #if defined(PNG_READ_DITHER_SUPPORTED)
  643.    if (png_ptr->transformations & PNG_DITHER)
  644.    {
  645.       if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
  646.          (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
  647.          png_ptr->palette_lookup && info_ptr->bit_depth == 8)
  648.       {
  649.          info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
  650.       }
  651.    }
  652. #endif
  653.  
  654. #if defined(PNG_READ_PACK_SUPPORTED)
  655.    if ((png_ptr->transformations & PNG_PACK) && info_ptr->bit_depth < 8)
  656.       info_ptr->bit_depth = 8;
  657. #endif
  658.  
  659. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  660.    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
  661.       !(info_ptr->color_type & PNG_COLOR_MASK_COLOR))
  662.       info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
  663. #endif
  664.    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  665.       info_ptr->channels = 1;
  666.    else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
  667.       info_ptr->channels = 3;
  668.    else
  669.       info_ptr->channels = 1;
  670.    if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
  671.       info_ptr->channels++;
  672.    info_ptr->pixel_depth = info_ptr->channels * info_ptr->bit_depth;
  673.    info_ptr->rowbytes = ((info_ptr->width * info_ptr->pixel_depth + 7) >> 3);
  674. }
  675.  
  676. /* transform the row.  The order of transformations is significant,
  677.    and is very touchy.  If you add a transformation, take care to
  678.    decide how it fits in with the other transformations here */
  679. void
  680. png_do_read_transformations(png_struct *png_ptr)
  681. {
  682. #if defined(PNG_READ_EXPAND_SUPPORTED)
  683.    if ((png_ptr->transformations & PNG_EXPAND) &&
  684.       png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
  685.    {
  686.       png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
  687.          png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
  688.    }
  689.    else if (png_ptr->transformations & PNG_EXPAND)
  690.    {
  691.       if (png_ptr->num_trans)
  692.          png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
  693.             &(png_ptr->trans_values));
  694.       else
  695.          png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
  696.             NULL);
  697.    }
  698. #endif
  699.  
  700. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  701.    if (png_ptr->transformations & PNG_BACKGROUND)
  702.       png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
  703.          &(png_ptr->trans_values), &(png_ptr->background),
  704.          &(png_ptr->background_1),
  705.          png_ptr->gamma_table, png_ptr->gamma_from_1,
  706.          png_ptr->gamma_to_1, png_ptr->gamma_16_table,
  707.          png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
  708.          png_ptr->gamma_shift);
  709. #endif
  710.  
  711. #if defined(PNG_READ_GAMMA_SUPPORTED)
  712.    if ((png_ptr->transformations & PNG_GAMMA) &&
  713.       !(png_ptr->transformations & PNG_BACKGROUND))
  714.       png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
  715.          png_ptr->gamma_table, png_ptr->gamma_16_table,
  716.          png_ptr->gamma_shift);
  717. #endif
  718.  
  719. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  720.    if (png_ptr->transformations & PNG_16_TO_8)
  721.       png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
  722. #endif
  723.  
  724. #if defined(PNG_READ_DITHER_SUPPORTED)
  725.    if (png_ptr->transformations & PNG_DITHER)
  726.       png_do_dither(&(png_ptr->row_info), png_ptr->row_buf + 1,
  727.          png_ptr->palette_lookup, png_ptr->dither_index);
  728. #endif
  729.  
  730. #if defined(PNG_READ_INVERT_SUPPORTED)
  731.    if (png_ptr->transformations & PNG_INVERT_MONO)
  732.       png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
  733. #endif
  734.  
  735. #if defined(PNG_READ_SHIFT_SUPPORTED)
  736.    if (png_ptr->transformations & PNG_SHIFT)
  737.       png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
  738.          &(png_ptr->shift));
  739. #endif
  740.  
  741. #if defined(PNG_READ_PACK_SUPPORTED)
  742.    if (png_ptr->transformations & PNG_PACK)
  743.       png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
  744. #endif
  745.  
  746. #if defined(PNG_READ_BGR_SUPPORTED)
  747.    if (png_ptr->transformations & PNG_BGR)
  748.       png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
  749. #endif
  750.  
  751. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  752.    if (png_ptr->transformations & PNG_GRAY_TO_RGB)
  753.       png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
  754. #endif
  755.  
  756. #if defined(PNG_READ_SWAP_SUPPORTED)
  757.    if (png_ptr->transformations & PNG_SWAP_BYTES)
  758.       png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
  759. #endif
  760.  
  761. #if defined(PNG_READ_FILLER_SUPPORTED)
  762.    if (png_ptr->transformations & PNG_FILLER)
  763.       png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
  764.          png_ptr->filler, png_ptr->filler_loc);
  765. #endif
  766. }
  767.  
  768. #if defined(PNG_READ_PACK_SUPPORTED)
  769. /* unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
  770.    without changing the actual values.  Thus, if you had a row with
  771.    a bit depth of 1, you would end up with bytes that only contained
  772.    the numbers 0 or 1.  If you would rather they contain 0 and 255, use
  773.    png_do_shift() after this. */
  774. void
  775. png_do_unpack(png_row_info *row_info, png_byte *row)
  776. {
  777.    if (row && row_info && row_info->bit_depth < 8)
  778.    {
  779.       switch (row_info->bit_depth)
  780.       {
  781.          case 1:
  782.          {
  783.             png_byte *sp;
  784.             png_byte *dp;
  785.             int shift;
  786.             png_uint_32 i;
  787.  
  788.             sp = row + (png_size_t)((row_info->width - 1) >> 3);
  789.             dp = row + (png_size_t)row_info->width - 1;
  790.             shift = 7 - (int)((row_info->width + 7) & 7);
  791.             for (i = 0; i < row_info->width; i++)
  792.             {
  793.                *dp = (*sp >> shift) & 0x1;
  794.                if (shift == 7)
  795.                {
  796.                   shift = 0;
  797.                   sp--;
  798.                }
  799.                else
  800.                   shift++;
  801.  
  802.                dp--;
  803.             }
  804.             break;
  805.          }
  806.          case 2:
  807.          {
  808.             png_byte *sp;
  809.             png_byte *dp;
  810.             int shift;
  811.             png_uint_32 i;
  812.  
  813.             sp = row + (png_size_t)((row_info->width - 1) >> 2);
  814.             dp = row + (png_size_t)row_info->width - 1;
  815.             shift = (int)((3 - ((row_info->width + 3) & 3)) << 1);
  816.             for (i = 0; i < row_info->width; i++)
  817.             {
  818.                *dp = (*sp >> shift) & 0x3;
  819.                if (shift == 6)
  820.                {
  821.                   shift = 0;
  822.                   sp--;
  823.                }
  824.                else
  825.                   shift += 2;
  826.  
  827.                dp--;
  828.             }
  829.             break;
  830.          }
  831.          case 4:
  832.          {
  833.             png_byte *sp;
  834.             png_byte *dp;
  835.             int shift;
  836.             png_uint_32 i;
  837.  
  838.             sp = row + (png_size_t)((row_info->width - 1) >> 1);
  839.             dp = row + (png_size_t)row_info->width - 1;
  840.             shift = (int)((1 - ((row_info->width + 1) & 1)) << 4);
  841.             for (i = 0; i < row_info->width; i++)
  842.             {
  843.                *dp = (*sp >> shift) & 0xf;
  844.                if (shift == 4)
  845.                {
  846.                   shift = 0;
  847.                   sp--;
  848.                }
  849.                else
  850.                   shift = 4;
  851.  
  852.                dp--;
  853.             }
  854.             break;
  855.          }
  856.       }
  857.       row_info->bit_depth = 8;
  858.       row_info->pixel_depth = 8 * row_info->channels;
  859.       row_info->rowbytes = row_info->width * row_info->channels;
  860.    }
  861. }
  862. #endif
  863.  
  864. #if defined(PNG_READ_SHIFT_SUPPORTED)
  865. /* reverse the effects of png_do_shift.  This routine merely shifts the
  866.    pixels back to their significant bits values.  Thus, if you have
  867.    a row of bit depth 8, but only 5 are significant, this will shift
  868.    the values back to 0 through 31 */
  869. void
  870. png_do_unshift(png_row_info *row_info, png_byte *row,
  871.    png_color_8 *sig_bits)
  872. {
  873.    if (row && row_info && sig_bits &&
  874.       row_info->color_type != PNG_COLOR_TYPE_PALETTE)
  875.    {
  876.       int shift[4];
  877.       int channels;
  878.  
  879.       channels = 0;
  880.       if (row_info->color_type & PNG_COLOR_MASK_COLOR)
  881.       {
  882.          shift[channels++] = row_info->bit_depth - sig_bits->red;
  883.          shift[channels++] = row_info->bit_depth - sig_bits->green;
  884.          shift[channels++] = row_info->bit_depth - sig_bits->blue;
  885.       }
  886.       else
  887.       {
  888.          shift[channels++] = row_info->bit_depth - sig_bits->gray;
  889.       }
  890.       if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
  891.       {
  892.          shift[channels++] = row_info->bit_depth - sig_bits->alpha;
  893.       }
  894.  
  895.       switch (row_info->bit_depth)
  896.       {
  897.          case 2:
  898.          {
  899.             png_byte *bp;
  900.             png_uint_32 i;
  901.  
  902.             for (bp = row, i = 0;
  903.                i < row_info->rowbytes;
  904.                i++, bp++)
  905.             {
  906.                *bp >>= 1;
  907.                *bp &= 0x55;
  908.             }
  909.             break;
  910.          }
  911.          case 4:
  912.          {
  913.             png_byte *bp, mask;
  914.             png_uint_32 i;
  915.  
  916.             mask = (png_byte)(((int)0xf0 >> shift[0]) & (int)0xf0) |
  917.                ((int)0xf >> shift[0]);
  918.             for (bp = row, i = 0;
  919.                i < row_info->rowbytes;
  920.                i++, bp++)
  921.             {
  922.                *bp >>= shift[0];
  923.                *bp &= mask;
  924.             }
  925.             break;
  926.          }
  927.          case 8:
  928.          {
  929.             png_byte *bp;
  930.             png_uint_32 i;
  931.  
  932.             for (bp = row, i = 0;
  933.                i < row_info->width; i++)
  934.             {
  935.                int c;
  936.  
  937.                for (c = 0; c < row_info->channels; c++, bp++)
  938.                {
  939.                   *bp >>= shift[c];
  940.                }
  941.             }
  942.             break;
  943.          }
  944.          case 16:
  945.          {
  946.             png_byte *bp;
  947.             png_uint_16 value;
  948.             png_uint_32 i;
  949.  
  950.             for (bp = row, i = 0;
  951.                i < row_info->width; i++)
  952.             {
  953.                int c;
  954.  
  955.                for (c = 0; c < row_info->channels; c++, bp += 2)
  956.                {
  957.                   value = (*bp << 8) + *(bp + 1);
  958.                   value >>= shift[c];
  959.                   *bp = value >> 8;
  960.                   *(bp + 1) = value & 0xff;
  961.                }
  962.             }
  963.             break;
  964.          }
  965.       }
  966.    }
  967. }
  968. #endif
  969.  
  970. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  971. /* chop rows of bit depth 16 down to 8 */
  972. void
  973. png_do_chop(png_row_info *row_info, png_byte *row)
  974. {
  975.    if (row && row_info && row_info->bit_depth == 16)
  976.    {
  977.       png_byte *sp, *dp;
  978.       png_uint_32 i;
  979.  
  980.       sp = row + 2;
  981.       dp = row + 1;
  982.       for (i = 1; i < row_info->width * row_info->channels; i++)
  983.       {
  984.          *dp = *sp;
  985.          sp += 2;
  986.          dp++;
  987.       }
  988.       row_info->bit_depth = 8;
  989.       row_info->pixel_depth = 8 * row_info->channels;
  990.       row_info->rowbytes = row_info->width * row_info->channels;
  991.    }
  992. }
  993. #endif
  994.  
  995. #if defined(PNG_READ_FILLER_SUPPORTED)
  996. /* add filler byte */
  997. void
  998. png_do_read_filler(png_row_info *row_info, png_byte *row,
  999.    png_byte filler, png_byte filler_loc)
  1000. {
  1001.    if (row && row_info && row_info->color_type == 2 &&
  1002.       row_info->bit_depth == 8)
  1003.    {
  1004.       if (filler_loc == PNG_FILLER_AFTER)
  1005.       {
  1006.          png_byte *sp, *dp;
  1007.          png_uint_32 i;
  1008.  
  1009.          for (i = 1, sp = row + (png_size_t)row_info->width * 3,
  1010.             dp = row + (png_size_t)row_info->width * 4;
  1011.             i < row_info->width;
  1012.             i++)
  1013.          {
  1014.             *(--dp) = filler;
  1015.             *(--dp) = *(--sp);
  1016.             *(--dp) = *(--sp);
  1017.             *(--dp) = *(--sp);
  1018.          }
  1019.          *(--dp) = filler;
  1020.          row_info->channels = 4;
  1021.          row_info->pixel_depth = 32;
  1022.          row_info->rowbytes = row_info->width * 4;
  1023.       }
  1024.       else
  1025.       {
  1026.          png_byte *sp, *dp;
  1027.          png_uint_32 i;
  1028.  
  1029.          for (i = 0, sp = row + (png_size_t)row_info->width * 3,
  1030.             dp = row + (png_size_t)row_info->width * 4;
  1031.             i < row_info->width;
  1032.             i++)
  1033.          {
  1034.             *(--dp) = *(--sp);
  1035.             *(--dp) = *(--sp);
  1036.             *(--dp) = *(--sp);
  1037.             *(--dp) = filler;
  1038.          }
  1039.          row_info->channels = 4;
  1040.          row_info->pixel_depth = 32;
  1041.          row_info->rowbytes = row_info->width * 4;
  1042.       }
  1043.    }
  1044. }
  1045. #endif
  1046.  
  1047. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  1048. /* expand grayscale files to rgb, with or without alpha */
  1049. void
  1050. png_do_gray_to_rgb(png_row_info *row_info, png_byte *row)
  1051. {
  1052.    if (row && row_info && row_info->bit_depth >= 8 &&
  1053.       !(row_info->color_type & PNG_COLOR_MASK_COLOR))
  1054.    {
  1055.       if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
  1056.       {
  1057.          if (row_info->bit_depth == 8)
  1058.          {
  1059.             png_byte *sp, *dp;
  1060.             png_uint_32 i;
  1061.  
  1062.             for (i = 0, sp = row + (png_size_t)row_info->width - 1,
  1063.                dp = row + (png_size_t)row_info->width * 3 - 1;
  1064.                i < row_info->width;
  1065.                i++)
  1066.             {
  1067.                *(dp--) = *sp;
  1068.                *(dp--) = *sp;
  1069.                *(dp--) = *sp;
  1070.                sp--;
  1071.             }
  1072.          }
  1073.          else
  1074.          {
  1075.             png_byte *sp, *dp;
  1076.             png_uint_32 i;
  1077.  
  1078.             for (i = 0, sp = row + (png_size_t)row_info->width * 2 - 1,
  1079.                dp = row + (png_size_t)row_info->width * 6 - 1;
  1080.                i < row_info->width;
  1081.                i++)
  1082.             {
  1083.                *(dp--) = *sp;
  1084.                *(dp--) = *(sp - 1);
  1085.                *(dp--) = *sp;
  1086.                *(dp--) = *(sp - 1);
  1087.                *(dp--) = *sp;
  1088.                *(dp--) = *(sp - 1);
  1089.                sp--;
  1090.                sp--;
  1091.             }
  1092.          }
  1093.       }
  1094.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  1095.       {
  1096.          if (row_info->bit_depth == 8)
  1097.          {
  1098.             png_byte *sp, *dp;
  1099.             png_uint_32 i;
  1100.  
  1101.             for (i = 0, sp = row + (png_size_t)row_info->width * 2 - 1,
  1102.                dp = row + (png_size_t)row_info->width * 4 - 1;
  1103.                i < row_info->width;
  1104.                i++)
  1105.             {
  1106.                *(dp--) = *(sp--);
  1107.                *(dp--) = *sp;
  1108.                *(dp--) = *sp;
  1109.                *(dp--) = *sp;
  1110.                sp--;
  1111.             }
  1112.          }
  1113.          else
  1114.          {
  1115.             png_byte *sp, *dp;
  1116.             png_uint_32 i;
  1117.  
  1118.             for (i = 0, sp = row + (png_size_t)row_info->width * 4 - 1,
  1119.                dp = row + (png_size_t)row_info->width * 8 - 1;
  1120.                i < row_info->width;
  1121.                i++)
  1122.             {
  1123.                *(dp--) = *(sp--);
  1124.                *(dp--) = *(sp--);
  1125.                *(dp--) = *sp;
  1126.                *(dp--) = *(sp - 1);
  1127.                *(dp--) = *sp;
  1128.                *(dp--) = *(sp - 1);
  1129.                *(dp--) = *sp;
  1130.                *(dp--) = *(sp - 1);
  1131.                sp--;
  1132.                sp--;
  1133.             }
  1134.          }
  1135.       }
  1136.       row_info->channels += 2;
  1137.       row_info->color_type |= PNG_COLOR_MASK_COLOR;
  1138.       row_info->pixel_depth = row_info->channels * row_info->bit_depth;
  1139.       row_info->rowbytes = ((row_info->width *
  1140.          row_info->pixel_depth + 7) >> 3);
  1141.    }
  1142. }
  1143. #endif
  1144.  
  1145. /* build a grayscale palette.  Palette is assumed to be 1 << bit_depth
  1146.    large of png_color.  This lets grayscale images be treated as
  1147.    paletted.  Most useful for gamma correction and simplification
  1148.    of code. */
  1149. void
  1150. png_build_grayscale_palette(int bit_depth, png_color *palette)
  1151. {
  1152.    int num_palette;
  1153.    int color_inc;
  1154.    int i;
  1155.    int v;
  1156.  
  1157.    if (!palette)
  1158.       return;
  1159.  
  1160.    switch (bit_depth)
  1161.    {
  1162.       case 1:
  1163.          num_palette = 2;
  1164.          color_inc = 0xff;
  1165.          break;
  1166.       case 2:
  1167.          num_palette = 4;
  1168.          color_inc = 0x55;
  1169.          break;
  1170.       case 4:
  1171.          num_palette = 16;
  1172.          color_inc = 0x11;
  1173.          break;
  1174.       case 8:
  1175.          num_palette = 256;
  1176.          color_inc = 1;
  1177.          break;
  1178.       default:
  1179.          num_palette = 0;
  1180.          break;
  1181.    }
  1182.  
  1183.    for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
  1184.    {
  1185.       palette[i].red = v;
  1186.       palette[i].green = v;
  1187.       palette[i].blue = v;
  1188.    }
  1189. }
  1190.  
  1191. #if defined(PNG_READ_DITHER_SUPPORTED)
  1192. void
  1193. png_correct_palette(png_struct *png_ptr, png_color *palette,
  1194.    int num_palette)
  1195. {
  1196.    if ((png_ptr->transformations & (PNG_GAMMA)) &&
  1197.       (png_ptr->transformations & (PNG_BACKGROUND)))
  1198.    {
  1199.       if (png_ptr->color_type == 3)
  1200.       {
  1201.          int i;
  1202.          png_color back, back_1;
  1203.  
  1204.          back.red = png_ptr->gamma_table[png_ptr->palette[
  1205.             png_ptr->background.index].red];
  1206.          back.green = png_ptr->gamma_table[png_ptr->palette[
  1207.             png_ptr->background.index].green];
  1208.          back.blue = png_ptr->gamma_table[png_ptr->palette[
  1209.             png_ptr->background.index].blue];
  1210.  
  1211.          back_1.red = png_ptr->gamma_to_1[png_ptr->palette[
  1212.             png_ptr->background.index].red];
  1213.          back_1.green = png_ptr->gamma_to_1[png_ptr->palette[
  1214.             png_ptr->background.index].green];
  1215.          back_1.blue = png_ptr->gamma_to_1[png_ptr->palette[
  1216.             png_ptr->background.index].blue];
  1217.  
  1218.          for (i = 0; i < num_palette; i++)
  1219.          {
  1220.             if (i < (int)png_ptr->num_trans &&
  1221.                png_ptr->trans[i] == 0)
  1222.             {
  1223.                palette[i] = back;
  1224.             }
  1225.             else if (i < (int)png_ptr->num_trans &&
  1226.                png_ptr->trans[i] != 0xff)
  1227.             {
  1228.                int v;
  1229.  
  1230.                v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
  1231.                v = (int)(((png_uint_32)(v) *
  1232.                   (png_uint_32)(png_ptr->trans[i]) +
  1233.                   (png_uint_32)(back_1.red) *
  1234.                   (png_uint_32)(255 - png_ptr->trans[i]) +
  1235.                   127) / 255);
  1236.                palette[i].red = png_ptr->gamma_from_1[v];
  1237.  
  1238.                v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
  1239.                v = (int)(((png_uint_32)(v) *
  1240.                   (png_uint_32)(png_ptr->trans[i]) +
  1241.                   (png_uint_32)(back_1.green) *
  1242.                   (png_uint_32)(255 - png_ptr->trans[i]) +
  1243.                   127) / 255);
  1244.                palette[i].green = png_ptr->gamma_from_1[v];
  1245.  
  1246.                v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
  1247.                v = (int)(((png_uint_32)(v) *
  1248.                   (png_uint_32)(png_ptr->trans[i]) +
  1249.                   (png_uint_32)(back_1.blue) *
  1250.                   (png_uint_32)(255 - png_ptr->trans[i]) +
  1251.                   127) / 255);
  1252.                palette[i].blue = png_ptr->gamma_from_1[v];
  1253.             }
  1254.             else
  1255.             {
  1256.                palette[i].red = png_ptr->gamma_table[palette[i].red];
  1257.                palette[i].green = png_ptr->gamma_table[palette[i].green];
  1258.                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  1259.             }
  1260.          }
  1261.       }
  1262.       else
  1263.       {
  1264.          int i, back;
  1265.  
  1266.          back = png_ptr->gamma_table[png_ptr->background.gray];
  1267.  
  1268.          for (i = 0; i < num_palette; i++)
  1269.          {
  1270.             if (palette[i].red == png_ptr->trans_values.gray)
  1271.             {
  1272.                palette[i].red = back;
  1273.                palette[i].green = back;
  1274.                palette[i].blue = back;
  1275.             }
  1276.             else
  1277.             {
  1278.                palette[i].red = png_ptr->gamma_table[palette[i].red];
  1279.                palette[i].green = png_ptr->gamma_table[palette[i].green];
  1280.                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  1281.             }
  1282.          }
  1283.       }
  1284.    }
  1285.    else if (png_ptr->transformations & (PNG_GAMMA))
  1286.    {
  1287.       int i;
  1288.  
  1289.       for (i = 0; i < num_palette; i++)
  1290.       {
  1291.          palette[i].red = png_ptr->gamma_table[palette[i].red];
  1292.          palette[i].green = png_ptr->gamma_table[palette[i].green];
  1293.          palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  1294.       }
  1295.    }
  1296.    else if (png_ptr->transformations & (PNG_BACKGROUND))
  1297.    {
  1298.       if (png_ptr->color_type == 3)
  1299.       {
  1300.          int i;
  1301.          png_byte br, bg, bb;
  1302.  
  1303.          br = palette[png_ptr->background.index].red;
  1304.          bg = palette[png_ptr->background.index].green;
  1305.          bb = palette[png_ptr->background.index].blue;
  1306.  
  1307.          for (i = 0; i < num_palette; i++)
  1308.          {
  1309.             if (i >= (int)png_ptr->num_trans ||
  1310.                png_ptr->trans[i] == 0)
  1311.             {
  1312.                palette[i].red = br;
  1313.                palette[i].green = bg;
  1314.                palette[i].blue = bb;
  1315.             }
  1316.             else if (i < (int)png_ptr->num_trans ||
  1317.                png_ptr->trans[i] != 0xff)
  1318.             {
  1319.                palette[i].red = (png_byte)((
  1320.                   (png_uint_32)(png_ptr->palette[i].red) *
  1321.                   (png_uint_32)(png_ptr->trans[i]) +
  1322.                   (png_uint_32)(br) *
  1323.                   (png_uint_32)(255 - png_ptr->trans[i]) +
  1324.                   127) / 255);
  1325.                palette[i].green = (png_byte)((
  1326.                   (png_uint_32)(png_ptr->palette[i].green) *
  1327.                   (png_uint_32)(png_ptr->trans[i]) +
  1328.                   (png_uint_32)(bg) *
  1329.                   (png_uint_32)(255 - png_ptr->trans[i]) +
  1330.                   127) / 255);
  1331.                palette[i].blue = (png_byte)((
  1332.                   (png_uint_32)(png_ptr->palette[i].blue) *
  1333.                   (png_uint_32)(png_ptr->trans[i]) +
  1334.                   (png_uint_32)(bb) *
  1335.                   (png_uint_32)(255 - png_ptr->trans[i]) +
  1336.                   127) / 255);
  1337.             }
  1338.          }
  1339.       }
  1340.       else /* assume grayscale palette (what else could it be?) */
  1341.       {
  1342.          int i;
  1343.  
  1344.          for (i = 0; i < num_palette; i++)
  1345.          {
  1346.             if (i == (int)png_ptr->trans_values.gray)
  1347.             {
  1348.                palette[i].red = (png_byte)png_ptr->background.gray;
  1349.                palette[i].green = (png_byte)png_ptr->background.gray;
  1350.                palette[i].blue = (png_byte)png_ptr->background.gray;
  1351.             }
  1352.          }
  1353.       }
  1354.    }
  1355. }
  1356. #endif
  1357.  
  1358. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  1359. /* replace any alpha or transparency with the supplied background color.
  1360.    background is the color (in rgb or grey or palette index, as
  1361.    appropriate).  note that paletted files are taken care of elsewhere */
  1362. void
  1363. png_do_background(png_row_info *row_info, png_byte *row,
  1364.    png_color_16 *trans_values, png_color_16 *background,
  1365.    png_color_16 *background_1,
  1366.    png_byte *gamma_table, png_byte *gamma_from_1, png_byte *gamma_to_1,
  1367.    png_uint_16 **gamma_16, png_uint_16 **gamma_16_from_1,
  1368.    png_uint_16 **gamma_16_to_1, int gamma_shift)
  1369. {
  1370.    if (row && row_info && background &&
  1371.       (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
  1372.       (row_info->color_type != PNG_COLOR_TYPE_PALETTE &&
  1373.       trans_values)))
  1374.    {
  1375.       switch (row_info->color_type)
  1376.       {
  1377.          case PNG_COLOR_TYPE_GRAY:
  1378.          {
  1379.             switch (row_info->bit_depth)
  1380.             {
  1381.                case 1:
  1382.                {
  1383.                   png_byte *sp;
  1384.                   int shift;
  1385.                   png_uint_32 i;
  1386.  
  1387.                   sp = row;
  1388.                   shift = 7;
  1389.                   for (i = 0; i < row_info->width; i++)
  1390.                   {
  1391.                      if (((*sp >> shift) & 0x1) ==
  1392.                         trans_values->gray)
  1393.                      {
  1394.                         *sp &= ((0x7f7f >> (7 - shift)) & 0xff);
  1395.                         *sp |= (background->gray << shift);
  1396.                      }
  1397.                      if (!shift)
  1398.                      {
  1399.                         shift = 7;
  1400.                         sp++;
  1401.                      }
  1402.                      else
  1403.                         shift--;
  1404.                   }
  1405.                   break;
  1406.                }
  1407.                case 2:
  1408.                {
  1409.                   png_byte *sp;
  1410.                   int shift;
  1411.                   png_uint_32 i;
  1412.  
  1413.                   sp = row;
  1414.                   shift = 6;
  1415.                   for (i = 0; i < row_info->width; i++)
  1416.                   {
  1417.                      if (((*sp >> shift) & 0x3) ==
  1418.                         trans_values->gray)
  1419.                      {
  1420.                         *sp &= ((0x3f3f >> (6 - shift)) & 0xff);
  1421.                         *sp |= (background->gray << shift);
  1422.                      }
  1423.                      if (!shift)
  1424.                      {
  1425.                         shift = 6;
  1426.                         sp++;
  1427.                      }
  1428.                      else
  1429.                         shift -= 2;
  1430.                   }
  1431.                   break;
  1432.                }
  1433.                case 4:
  1434.                {
  1435.                   png_byte *sp;
  1436.                   int shift;
  1437.                   png_uint_32 i;
  1438.  
  1439.                   sp = row + 1;
  1440.                   shift = 4;
  1441.                   for (i = 0; i < row_info->width; i++)
  1442.                   {
  1443.                      if (((*sp >> shift) & 0xf) ==
  1444.                         trans_values->gray)
  1445.                      {
  1446.                         *sp &= ((0xf0f >> (4 - shift)) & 0xff);
  1447.                         *sp |= (background->gray << shift);
  1448.                      }
  1449.                      if (!shift)
  1450.                      {
  1451.                         shift = 4;
  1452.                         sp++;
  1453.                      }
  1454.                      else
  1455.                         shift -= 4;
  1456.                   }
  1457.                   break;
  1458.                }
  1459.                case 8:
  1460.                {
  1461. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1462.                   if (gamma_table)
  1463.                   {
  1464.                      png_byte *sp;
  1465.                      png_uint_32 i;
  1466.  
  1467.                      for (i = 0, sp = row;
  1468.                         i < row_info->width; i++, sp++)
  1469.                      {
  1470.                         if (*sp == trans_values->gray)
  1471.                         {
  1472.                            *sp = background->gray;
  1473.                         }
  1474.                         else
  1475.                         {
  1476.                            *sp = gamma_table[*sp];
  1477.                         }
  1478.                      }
  1479.                   }
  1480.                   else
  1481. #endif
  1482.                   {
  1483.                      png_byte *sp;
  1484.                      png_uint_32 i;
  1485.  
  1486.                      for (i = 0, sp = row;
  1487.                         i < row_info->width; i++, sp++)
  1488.                      {
  1489.                         if (*sp == trans_values->gray)
  1490.                         {
  1491.                            *sp = background->gray;
  1492.                         }
  1493.                      }
  1494.                   }
  1495.                   break;
  1496.                }
  1497.                case 16:
  1498.                {
  1499. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1500.                   if (gamma_16)
  1501.                   {
  1502.                      png_byte *sp;
  1503.                      png_uint_32 i;
  1504.  
  1505.                      for (i = 0, sp = row;
  1506.                         i < row_info->width; i++, sp += 2)
  1507.                      {
  1508.                         png_uint_16 v;
  1509.  
  1510.                         v = ((png_uint_16)(*sp) << 8) +
  1511.                            (png_uint_16)(*(sp + 1));
  1512.                         if (v == trans_values->gray)
  1513.                         {
  1514.                            *sp = (background->gray >> 8) & 0xff;
  1515.                            *(sp + 1) = background->gray & 0xff;
  1516.                         }
  1517.                         else
  1518.                         {
  1519.                            v = gamma_16[
  1520.                               *(sp + 1) >> gamma_shift][*sp];
  1521.                            *sp = (v >> 8) & 0xff;
  1522.                            *(sp + 1) = v & 0xff;
  1523.                         }
  1524.                      }
  1525.                   }
  1526.                   else
  1527. #endif
  1528.                   {
  1529.                      png_byte *sp;
  1530.                      png_uint_32 i;
  1531.  
  1532.                      for (i = 0, sp = row;
  1533.                         i < row_info->width; i++, sp += 2)
  1534.                      {
  1535.                         png_uint_16 v;
  1536.  
  1537.                         v = ((png_uint_16)(*sp) << 8) +
  1538.                            (png_uint_16)(*(sp + 1));
  1539.                         if (v == trans_values->gray)
  1540.                         {
  1541.                            *sp = (background->gray >> 8) & 0xff;
  1542.                            *(sp + 1) = background->gray & 0xff;
  1543.                         }
  1544.                      }
  1545.                   }
  1546.                   break;
  1547.                }
  1548.             }
  1549.             break;
  1550.          }
  1551.          case PNG_COLOR_TYPE_RGB:
  1552.          {
  1553.             if (row_info->bit_depth == 8)
  1554.             {
  1555. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1556.                if (gamma_table)
  1557.                {
  1558.                   png_byte *sp;
  1559.                   png_uint_32 i;
  1560.  
  1561.                   for (i = 0, sp = row;
  1562.                      i < row_info->width; i++, sp += 3)
  1563.                   {
  1564.                      if (*sp == trans_values->red &&
  1565.                         *(sp + 1) == trans_values->green &&
  1566.                         *(sp + 2) == trans_values->blue)
  1567.                      {
  1568.                         *sp = background->red;
  1569.                         *(sp + 1) = background->green;
  1570.                         *(sp + 2) = background->blue;
  1571.                      }
  1572.                      else
  1573.                      {
  1574.                         *sp = gamma_table[*sp];
  1575.                         *(sp + 1) = gamma_table[*(sp + 1)];
  1576.                         *(sp + 2) = gamma_table[*(sp + 2)];
  1577.                      }
  1578.                   }
  1579.                }
  1580.                else
  1581. #endif
  1582.                {
  1583.                   png_byte *sp;
  1584.                   png_uint_32 i;
  1585.  
  1586.                   for (i = 0, sp = row;
  1587.                      i < row_info->width; i++, sp += 3)
  1588.                   {
  1589.                      if (*sp == trans_values->red &&
  1590.                         *(sp + 1) == trans_values->green &&
  1591.                         *(sp + 2) == trans_values->blue)
  1592.                      {
  1593.                         *sp = background->red;
  1594.                         *(sp + 1) = background->green;
  1595.                         *(sp + 2) = background->blue;
  1596.                      }
  1597.                   }
  1598.                }
  1599.             }
  1600.             else if (row_info->bit_depth == 16)
  1601.             {
  1602. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1603.                if (gamma_16)
  1604.                {
  1605.                   png_byte *sp;
  1606.                   png_uint_32 i;
  1607.  
  1608.                   for (i = 0, sp = row;
  1609.                      i < row_info->width; i++, sp += 6)
  1610.                   {
  1611.                      png_uint_16 r, g, b;
  1612.  
  1613.                      r = ((png_uint_16)(*sp) << 8) +
  1614.                         (png_uint_16)(*(sp + 1));
  1615.                      g = ((png_uint_16)(*(sp + 2)) << 8) +
  1616.                         (png_uint_16)(*(sp + 3));
  1617.                      b = ((png_uint_16)(*(sp + 4)) << 8) +
  1618.                         (png_uint_16)(*(sp + 5));
  1619.                      if (r == trans_values->red &&
  1620.                         g == trans_values->green &&
  1621.                         b == trans_values->blue)
  1622.                      {
  1623.                         *sp = (background->red >> 8) & 0xff;
  1624.                         *(sp + 1) = background->red & 0xff;
  1625.                         *(sp + 2) = (background->green >> 8) & 0xff;
  1626.                         *(sp + 3) = background->green & 0xff;
  1627.                         *(sp + 4) = (background->blue >> 8) & 0xff;
  1628.                         *(sp + 5) = background->blue & 0xff;
  1629.                      }
  1630.                      else
  1631.                      {
  1632.                         png_uint_16 v;
  1633.                         v = gamma_16[
  1634.                            *(sp + 1) >> gamma_shift][*sp];
  1635.                         *sp = (v >> 8) & 0xff;
  1636.                         *(sp + 1) = v & 0xff;
  1637.                         v = gamma_16[
  1638.                            *(sp + 3) >> gamma_shift][*(sp + 2)];
  1639.                         *(sp + 2) = (v >> 8) & 0xff;
  1640.                         *(sp + 3) = v & 0xff;
  1641.                         v = gamma_16[
  1642.                            *(sp + 5) >> gamma_shift][*(sp + 4)];
  1643.                         *(sp + 4) = (v >> 8) & 0xff;
  1644.                         *(sp + 5) = v & 0xff;
  1645.                      }
  1646.                   }
  1647.                }
  1648.                else
  1649. #endif
  1650.                {
  1651.                   png_byte *sp;
  1652.                   png_uint_32 i;
  1653.  
  1654.                   for (i = 0, sp = row;
  1655.                      i < row_info->width; i++, sp += 6)
  1656.                   {
  1657.                      png_uint_16 r, g, b;
  1658.  
  1659.                      r = ((png_uint_16)(*sp) << 8) +
  1660.                         (png_uint_16)(*(sp + 1));
  1661.                      g = ((png_uint_16)(*(sp + 2)) << 8) +
  1662.                         (png_uint_16)(*(sp + 3));
  1663.                      b = ((png_uint_16)(*(sp + 4)) << 8) +
  1664.                         (png_uint_16)(*(sp + 5));
  1665.                      if (r == trans_values->red &&
  1666.                         g == trans_values->green &&
  1667.                         b == trans_values->blue)
  1668.                      {
  1669.                         *sp = (background->red >> 8) & 0xff;
  1670.                         *(sp + 1) = background->red & 0xff;
  1671.                         *(sp + 2) = (background->green >> 8) & 0xff;
  1672.                         *(sp + 3) = background->green & 0xff;
  1673.                         *(sp + 4) = (background->blue >> 8) & 0xff;
  1674.                         *(sp + 5) = background->blue & 0xff;
  1675.                      }
  1676.                   }
  1677.                }
  1678.             }
  1679.             break;
  1680.          }
  1681.          case PNG_COLOR_TYPE_GRAY_ALPHA:
  1682.          {
  1683.             switch (row_info->bit_depth)
  1684.             {
  1685.                case 8:
  1686.                {
  1687. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1688.                   if (gamma_to_1 && gamma_from_1 && gamma_table)
  1689.                   {
  1690.                      png_byte *sp, *dp;
  1691.                      png_uint_32 i;
  1692.  
  1693.                      for (i = 0, sp = row,
  1694.                         dp = row;
  1695.                         i < row_info->width; i++, sp += 2, dp++)
  1696.                      {
  1697.                         png_uint_16 a;
  1698.  
  1699.                         a = *(sp + 1);
  1700.                         if (a == 0xff)
  1701.                         {
  1702.                            *dp = gamma_table[*sp];
  1703.                         }
  1704.                         else if (a == 0)
  1705.                         {
  1706.                            *dp = background->gray;
  1707.                         }
  1708.                         else
  1709.                         {
  1710.                            png_uint_16 v;
  1711.  
  1712.                            v = gamma_to_1[*sp];
  1713.                            v = ((png_uint_16)(v) * a +
  1714.                               (png_uint_16)background_1->gray *
  1715.                               (255 - a) + 127) / 255;
  1716.                            *dp = gamma_from_1[v];
  1717.                         }
  1718.                      }
  1719.                   }
  1720.                   else
  1721. #endif
  1722.                   {
  1723.                      png_byte *sp, *dp;
  1724.                      png_uint_32 i;
  1725.  
  1726.                      for (i = 0, sp = row,
  1727.                         dp = row;
  1728.                         i < row_info->width; i++, sp += 2, dp++)
  1729.                      {
  1730.                         png_uint_16 a;
  1731.  
  1732.                         a = *(sp + 1);
  1733.                         if (a == 0xff)
  1734.                         {
  1735.                            *dp = *sp;
  1736.                         }
  1737.                         else if (a == 0)
  1738.                         {
  1739.                            *dp = background->gray;
  1740.                         }
  1741.                         else
  1742.                         {
  1743.                            *dp = ((png_uint_16)(*sp) * a +
  1744.                               (png_uint_16)background_1->gray *
  1745.                               (255 - a) + 127) / 255;
  1746.                         }
  1747.                      }
  1748.                   }
  1749.                   break;
  1750.                }
  1751.                case 16:
  1752.                {
  1753. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1754.                   if (gamma_16 && gamma_16_from_1 && gamma_16_to_1)
  1755.                   {
  1756.                      png_byte *sp, *dp;
  1757.                      png_uint_32 i;
  1758.  
  1759.                      for (i = 0, sp = row,
  1760.                         dp = row;
  1761.                         i < row_info->width; i++, sp += 4, dp += 2)
  1762.                      {
  1763.                         png_uint_16 a;
  1764.  
  1765.                         a = ((png_uint_16)(*(sp + 2)) << 8) +
  1766.                            (png_uint_16)(*(sp + 3));
  1767.                         if (a == (png_uint_16)0xffff)
  1768.                         {
  1769.                            png_uint_32 v;
  1770.  
  1771.                            v = gamma_16[
  1772.                               *(sp + 1) >> gamma_shift][*sp];
  1773.                            *dp = (png_byte)((v >> 8) & 0xff);
  1774.                            *(dp + 1) = (png_byte)(v & 0xff);
  1775.                         }
  1776.                         else if (a == 0)
  1777.                         {
  1778.                            *dp = (background->gray >> 8) & 0xff;
  1779.                            *(dp + 1) = background->gray & 0xff;
  1780.                         }
  1781.                         else
  1782.                         {
  1783.                            png_uint_32 g, v;
  1784.  
  1785.                            g = gamma_16_to_1[
  1786.                               *(sp + 1) >> gamma_shift][*sp];
  1787.                            v = (g * (png_uint_32)a +
  1788.                               (png_uint_32)background_1->gray *
  1789.                               (png_uint_32)((png_uint_16)65535L - a) +
  1790.                               (png_uint_16)32767) / (png_uint_16)65535L;
  1791.                            v = gamma_16_from_1[(size_t)(
  1792.                               (v & 0xff) >> gamma_shift)][(size_t)(v >> 8)];
  1793.                            *dp = (png_byte)((v >> 8) & 0xff);
  1794.                            *(dp + 1) = (png_byte)(v & 0xff);
  1795.                         }
  1796.                      }
  1797.                   }
  1798.                   else
  1799. #endif
  1800.                   {
  1801.                      png_byte *sp, *dp;
  1802.                      png_uint_32 i;
  1803.  
  1804.                      for (i = 0, sp = row,
  1805.                         dp = row;
  1806.                         i < row_info->width; i++, sp += 4, dp += 2)
  1807.                      {
  1808.                         png_uint_16 a;
  1809.  
  1810.                         a = ((png_uint_16)(*(sp + 2)) << 8) +
  1811.                            (png_uint_16)(*(sp + 3));
  1812.                         if (a == (png_uint_16)0xffff)
  1813.                         {
  1814.                            memcpy(dp, sp, 2);
  1815.                         }
  1816.                         else if (a == 0)
  1817.                         {
  1818.                            *dp = (background->gray >> 8) & 0xff;
  1819.                            *(dp + 1) = background->gray & 0xff;
  1820.                         }
  1821.                         else
  1822.                         {
  1823.                            png_uint_32 g, v;
  1824.  
  1825.                            g = ((png_uint_32)(*sp) << 8) +
  1826.                               (png_uint_32)(*(sp + 1));
  1827.                            v = (g * (png_uint_32)a +
  1828.                               (png_uint_32)background_1->gray *
  1829.                               (png_uint_32)((png_uint_16)65535L - a) +
  1830.                               (png_uint_16)32767) / (png_uint_16)65535L;
  1831.                            *dp = (png_byte)((v >> 8) & 0xff);
  1832.                            *(dp + 1) = (png_byte)(v & 0xff);
  1833.                         }
  1834.                      }
  1835.                   }
  1836.                   break;
  1837.                }
  1838.             }
  1839.             break;
  1840.          }
  1841.          case PNG_COLOR_TYPE_RGB_ALPHA:
  1842.          {
  1843.             if (row_info->bit_depth == 8)
  1844.             {
  1845. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1846.                if (gamma_to_1 && gamma_from_1 && gamma_table)
  1847.                {
  1848.                   png_byte *sp, *dp;
  1849.                   png_uint_32 i;
  1850.  
  1851.                   for (i = 0, sp = row,
  1852.                      dp = row;
  1853.                      i < row_info->width; i++, sp += 4, dp += 3)
  1854.                   {
  1855.                      png_uint_16 a;
  1856.  
  1857.                      a = *(sp + 3);
  1858.                      if (a == 0xff)
  1859.                      {
  1860.                         *dp = gamma_table[*sp];
  1861.                         *(dp + 1) = gamma_table[*(sp + 1)];
  1862.                         *(dp + 2) = gamma_table[*(sp + 2)];
  1863.                      }
  1864.                      else if (a == 0)
  1865.                      {
  1866.                         *dp = background->red;
  1867.                         *(dp + 1) = background->green;
  1868.                         *(dp + 2) = background->blue;
  1869.                      }
  1870.                      else
  1871.                      {
  1872.                         png_uint_16 v;
  1873.  
  1874.                         v = gamma_to_1[*sp];
  1875.                         v = ((png_uint_16)(v) * a +
  1876.                            (png_uint_16)background_1->red *
  1877.                            (255 - a) + 127) / 255;
  1878.                         *dp = gamma_from_1[v];
  1879.                         v = gamma_to_1[*(sp + 1)];
  1880.                         v = ((png_uint_16)(v) * a +
  1881.                            (png_uint_16)background_1->green *
  1882.                            (255 - a) + 127) / 255;
  1883.                         *(dp + 1) = gamma_from_1[v];
  1884.                         v = gamma_to_1[*(sp + 2)];
  1885.                         v = ((png_uint_16)(v) * a +
  1886.                            (png_uint_16)background_1->blue *
  1887.                            (255 - a) + 127) / 255;
  1888.                         *(dp + 2) = gamma_from_1[v];
  1889.                      }
  1890.                   }
  1891.                }
  1892.                else
  1893. #endif
  1894.                {
  1895.                   png_byte *sp, *dp;
  1896.                   png_uint_32 i;
  1897.  
  1898.                   for (i = 0, sp = row,
  1899.                      dp = row;
  1900.                      i < row_info->width; i++, sp += 4, dp += 3)
  1901.                   {
  1902.                      png_uint_16 a;
  1903.  
  1904.                      a = *(sp + 3);
  1905.                      if (a == 0xff)
  1906.                      {
  1907.                         *dp = *sp;
  1908.                         *(dp + 1) = *(sp + 1);
  1909.                         *(dp + 2) = *(sp + 2);
  1910.                      }
  1911.                      else if (a == 0)
  1912.                      {
  1913.                         *dp = background->red;
  1914.                         *(dp + 1) = background->green;
  1915.                         *(dp + 2) = background->blue;
  1916.                      }
  1917.                      else
  1918.                      {
  1919.                         *dp = ((png_uint_16)(*sp) * a +
  1920.                            (png_uint_16)background->red *
  1921.                            (255 - a) + 127) / 255;
  1922.                         *(dp + 1) = ((png_uint_16)(*(sp + 1)) * a +
  1923.                            (png_uint_16)background->green *
  1924.                            (255 - a) + 127) / 255;
  1925.                         *(dp + 2) = ((png_uint_16)(*(sp + 2)) * a +
  1926.                            (png_uint_16)background->blue *
  1927.                            (255 - a) + 127) / 255;
  1928.                      }
  1929.                   }
  1930.                }
  1931.             }
  1932.             else if (row_info->bit_depth == 16)
  1933.             {
  1934. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1935.                if (gamma_16 && gamma_16_from_1 && gamma_16_to_1)
  1936.                {
  1937.                   png_byte *sp, *dp;
  1938.                   png_uint_32 i;
  1939.  
  1940.                   for (i = 0, sp = row,
  1941.                      dp = row;
  1942.                      i < row_info->width; i++, sp += 8, dp += 6)
  1943.                   {
  1944.                      png_uint_16 a;
  1945.  
  1946.                      a = ((png_uint_16)(*(sp + 6)) << 8) +
  1947.                         (png_uint_16)(*(sp + 7));
  1948.                      if (a == (png_uint_16)0xffff)
  1949.                      {
  1950.                         png_uint_16 v;
  1951.  
  1952.                         v = gamma_16[
  1953.                            *(sp + 1) >> gamma_shift][*sp];
  1954.                         *dp = (v >> 8) & 0xff;
  1955.                         *(dp + 1) = v & 0xff;
  1956.                         v = gamma_16[
  1957.                            *(sp + 3) >> gamma_shift][*(sp + 2)];
  1958.                         *(dp + 2) = (v >> 8) & 0xff;
  1959.                         *(dp + 3) = v & 0xff;
  1960.                         v = gamma_16[
  1961.                            *(sp + 5) >> gamma_shift][*(sp + 4)];
  1962.                         *(dp + 4) = (v >> 8) & 0xff;
  1963.                         *(dp + 5) = v & 0xff;
  1964.                      }
  1965.                      else if (a == 0)
  1966.                      {
  1967.                         *dp = (background->red >> 8) & 0xff;
  1968.                         *(dp + 1) = background->red & 0xff;
  1969.                         *(dp + 2) = (background->green >> 8) & 0xff;
  1970.                         *(dp + 3) = background->green & 0xff;
  1971.                         *(dp + 4) = (background->blue >> 8) & 0xff;
  1972.                         *(dp + 5) = background->blue & 0xff;
  1973.                      }
  1974.                      else
  1975.                      {
  1976.                         png_uint_32 v;
  1977.  
  1978.                         v = gamma_16_to_1[
  1979.                            *(sp + 1) >> gamma_shift][*sp];
  1980.                         v = (v * (png_uint_32)a +
  1981.                            (png_uint_32)background->red *
  1982.                            (png_uint_32)((png_uint_16)65535L - a) +
  1983.                            (png_uint_16)32767) / (png_uint_16)65535L;
  1984.                         v = gamma_16_from_1[(size_t)(
  1985.                            (v & 0xff) >> gamma_shift)][(size_t)(v >> 8)];
  1986.                         *dp = (png_byte)((v >> 8) & 0xff);
  1987.                         *(dp + 1) = (png_byte)(v & 0xff);
  1988.                         v = gamma_16_to_1[
  1989.                            *(sp + 3) >> gamma_shift][*(sp + 2)];
  1990.                         v = (v * (png_uint_32)a +
  1991.                            (png_uint_32)background->green *
  1992.                            (png_uint_32)((png_uint_16)65535L - a) +
  1993.                            (png_uint_16)32767) / (png_uint_16)65535L;
  1994.                         v = gamma_16_from_1[(size_t)(
  1995.                            (v & 0xff) >> gamma_shift)][(size_t)(v >> 8)];
  1996.                         *(dp + 2) = (png_byte)((v >> 8) & 0xff);
  1997.                         *(dp + 3) = (png_byte)(v & 0xff);
  1998.                         v = gamma_16_to_1[
  1999.                            *(sp + 5) >> gamma_shift][*(sp + 4)];
  2000.                         v = (v * (png_uint_32)a +
  2001.                            (png_uint_32)background->blue *
  2002.                            (png_uint_32)((png_uint_16)65535L - a) +
  2003.                            (png_uint_16)32767) / (png_uint_16)65535L;
  2004.                         v = gamma_16_from_1[(size_t)(
  2005.                            (v & 0xff) >> gamma_shift)][(size_t)(v >> 8)];
  2006.                         *(dp + 4) = (png_byte)((v >> 8) & 0xff);
  2007.                         *(dp + 5) = (png_byte)(v & 0xff);
  2008.                      }
  2009.                   }
  2010.                }
  2011.                else
  2012. #endif
  2013.                {
  2014.                   png_byte *sp, *dp;
  2015.                   png_uint_32 i;
  2016.  
  2017.                   for (i = 0, sp = row,
  2018.                      dp = row;
  2019.                      i < row_info->width; i++, sp += 8, dp += 6)
  2020.                   {
  2021.                      png_uint_16 a;
  2022.  
  2023.                      a = ((png_uint_16)(*(sp + 6)) << 8) +
  2024.                         (png_uint_16)(*(sp + 7));
  2025.                      if (a == (png_uint_16)0xffff)
  2026.                      {
  2027.                         memcpy(dp, sp, 6);
  2028.                      }
  2029.                      else if (a == 0)
  2030.                      {
  2031.                         *dp = (background->red >> 8) & 0xff;
  2032.                         *(dp + 1) = background->red & 0xff;
  2033.                         *(dp + 2) = (background->green >> 8) & 0xff;
  2034.                         *(dp + 3) = background->green & 0xff;
  2035.                         *(dp + 4) = (background->blue >> 8) & 0xff;
  2036.                         *(dp + 5) = background->blue & 0xff;
  2037.                      }
  2038.                      else
  2039.                      {
  2040.                         png_uint_32 r, g, b, v;
  2041.  
  2042.                         r = ((png_uint_32)(*sp) << 8) +
  2043.                            (png_uint_32)(*(sp + 1));
  2044.                         g = ((png_uint_32)(*(sp + 2)) << 8) +
  2045.                            (png_uint_32)(*(sp + 3));
  2046.                         b = ((png_uint_32)(*(sp + 4)) << 8) +
  2047.                            (png_uint_32)(*(sp + 5));
  2048.                         v = (r * (png_uint_32)a +
  2049.                            (png_uint_32)background->red *
  2050.                            (png_uint_32)((png_uint_32)65535L - a) +
  2051.                            (png_uint_32)32767) / (png_uint_32)65535L;
  2052.                         *dp = (png_byte)((v >> 8) & 0xff);
  2053.                         *(dp + 1) = (png_byte)(v & 0xff);
  2054.                         v = (g * (png_uint_32)a +
  2055.                            (png_uint_32)background->green *
  2056.                            (png_uint_32)((png_uint_32)65535L - a) +
  2057.                            (png_uint_32)32767) / (png_uint_32)65535L;
  2058.                         *(dp + 2) = (png_byte)((v >> 8) & 0xff);
  2059.                         *(dp + 3) = (png_byte)(v & 0xff);
  2060.                         v = (b * (png_uint_32)a +
  2061.                            (png_uint_32)background->blue *
  2062.                            (png_uint_32)((png_uint_32)65535L - a) +
  2063.                            (png_uint_32)32767) / (png_uint_32)65535L;
  2064.                         *(dp + 4) = (png_byte)((v >> 8) & 0xff);
  2065.                         *(dp + 5) = (png_byte)(v & 0xff);
  2066.                      }
  2067.                   }
  2068.                }
  2069.             }
  2070.             break;
  2071.          }
  2072.       }
  2073.       if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
  2074.       {
  2075.          row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
  2076.          row_info->channels -= 1;
  2077.          row_info->pixel_depth = row_info->channels *
  2078.             row_info->bit_depth;
  2079.          row_info->rowbytes = ((row_info->width *
  2080.             row_info->pixel_depth + 7) >> 3);
  2081.       }
  2082.    }
  2083. }
  2084. #endif
  2085.  
  2086. #if defined(PNG_READ_GAMMA_SUPPORTED)
  2087. /* gamma correct the image, avoiding the alpha channel.  Make sure
  2088.    you do this after you deal with the trasparency issue on grayscale
  2089.    or rgb images. If your bit depth is 8, use gamma_table, if it is 16,
  2090.    use gamma_16_table and gamma_shift.  Build these with
  2091.    build_gamma_table().  If your bit depth < 8, gamma correct a
  2092.    palette, not the data.  */
  2093. void
  2094. png_do_gamma(png_row_info *row_info, png_byte *row,
  2095.    png_byte *gamma_table, png_uint_16 **gamma_16_table,
  2096.    int gamma_shift)
  2097. {
  2098.    if (row && row_info && ((row_info->bit_depth <= 8 && gamma_table) ||
  2099.       (row_info->bit_depth == 16 && gamma_16_table)))
  2100.    {
  2101.       switch (row_info->color_type)
  2102.       {
  2103.          case PNG_COLOR_TYPE_RGB:
  2104.          {
  2105.             if (row_info->bit_depth == 8)
  2106.             {
  2107.                png_byte *sp;
  2108.                png_uint_32 i;
  2109.  
  2110.                for (i = 0, sp = row;
  2111.                   i < row_info->width; i++)
  2112.                {
  2113.                   *sp = gamma_table[*sp];
  2114.                   sp++;
  2115.                   *sp = gamma_table[*sp];
  2116.                   sp++;
  2117.                   *sp = gamma_table[*sp];
  2118.                   sp++;
  2119.                }
  2120.             }
  2121.             else if (row_info->bit_depth == 16)
  2122.             {
  2123.                png_byte *sp;
  2124.                png_uint_32 i;
  2125.  
  2126.                for (i = 0, sp = row;
  2127.                   i < row_info->width; i++)
  2128.                {
  2129.                   png_uint_16 v;
  2130.  
  2131.                   v = gamma_16_table[*(sp + 1) >>
  2132.                      gamma_shift][*sp];
  2133.                   *sp = (v >> 8) & 0xff;
  2134.                   *(sp + 1) = v & 0xff;
  2135.                   sp += 2;
  2136.                   v = gamma_16_table[*(sp + 1) >>
  2137.                      gamma_shift][*sp];
  2138.                   *sp = (v >> 8) & 0xff;
  2139.                   *(sp + 1) = v & 0xff;
  2140.                   sp += 2;
  2141.                   v = gamma_16_table[*(sp + 1) >>
  2142.                      gamma_shift][*sp];
  2143.                   *sp = (v >> 8) & 0xff;
  2144.                   *(sp + 1) = v & 0xff;
  2145.                   sp += 2;
  2146.                }
  2147.             }
  2148.             break;
  2149.          }
  2150.          case PNG_COLOR_TYPE_RGB_ALPHA:
  2151.          {
  2152.             if (row_info->bit_depth == 8)
  2153.             {
  2154.                png_byte *sp;
  2155.                png_uint_32 i;
  2156.  
  2157.                for (i = 0, sp = row;
  2158.                   i < row_info->width; i++)
  2159.                {
  2160.                   *sp = gamma_table[*sp];
  2161.                   sp++;
  2162.                   *sp = gamma_table[*sp];
  2163.                   sp++;
  2164.                   *sp = gamma_table[*sp];
  2165.                   sp++;
  2166.                   sp++;
  2167.                }
  2168.             }
  2169.             else if (row_info->bit_depth == 16)
  2170.             {
  2171.                png_byte *sp;
  2172.                png_uint_32 i;
  2173.  
  2174.                for (i = 0, sp = row;
  2175.                   i < row_info->width; i++)
  2176.                {
  2177.                   png_uint_16 v;
  2178.  
  2179.                   v = gamma_16_table[*(sp + 1) >>
  2180.                      gamma_shift][*sp];
  2181.                   *sp = (v >> 8) & 0xff;
  2182.                   *(sp + 1) = v & 0xff;
  2183.                   sp += 2;
  2184.                   v = gamma_16_table[*(sp + 1) >>
  2185.                      gamma_shift][*sp];
  2186.                   *sp = (v >> 8) & 0xff;
  2187.                   *(sp + 1) = v & 0xff;
  2188.                   sp += 2;
  2189.                   v = gamma_16_table[*(sp + 1) >>
  2190.                      gamma_shift][*sp];
  2191.                   *sp = (v >> 8) & 0xff;
  2192.                   *(sp + 1) = v & 0xff;
  2193.                   sp += 4;
  2194.                }
  2195.             }
  2196.             break;
  2197.          }
  2198.          case PNG_COLOR_TYPE_GRAY_ALPHA:
  2199.          {
  2200.             if (row_info->bit_depth == 8)
  2201.             {
  2202.                png_byte *sp;
  2203.                png_uint_32 i;
  2204.  
  2205.                for (i = 0, sp = row;
  2206.                   i < row_info->width; i++)
  2207.                {
  2208.                   *sp = gamma_table[*sp];
  2209.                   sp++;
  2210.                   sp++;
  2211.                }
  2212.             }
  2213.             else if (row_info->bit_depth == 16)
  2214.             {
  2215.                png_byte *sp;
  2216.                png_uint_32 i;
  2217.  
  2218.                for (i = 0, sp = row;
  2219.                   i < row_info->width; i++)
  2220.                {
  2221.                   png_uint_16 v;
  2222.  
  2223.                   v = gamma_16_table[*(sp + 1) >>
  2224.                      gamma_shift][*sp];
  2225.                   *sp = (v >> 8) & 0xff;
  2226.                   *(sp + 1) = v & 0xff;
  2227.                   sp += 4;
  2228.                }
  2229.             }
  2230.             break;
  2231.          }
  2232.          case PNG_COLOR_TYPE_GRAY:
  2233.          {
  2234.             if (row_info->bit_depth == 8)
  2235.             {
  2236.                png_byte *sp;
  2237.                png_uint_32 i;
  2238.  
  2239.                for (i = 0, sp = row;
  2240.                   i < row_info->width; i++)
  2241.                {
  2242.                   *sp = gamma_table[*sp];
  2243.                   sp++;
  2244.                }
  2245.             }
  2246.             else if (row_info->bit_depth == 16)
  2247.             {
  2248.                png_byte *sp;
  2249.                png_uint_32 i;
  2250.  
  2251.                for (i = 0, sp = row;
  2252.                   i < row_info->width; i++)
  2253.                {
  2254.                   png_uint_16 v;
  2255.  
  2256.                   v = gamma_16_table[*(sp + 1) >>
  2257.                      gamma_shift][*sp];
  2258.                   *sp = (v >> 8) & 0xff;
  2259.                   *(sp + 1) = v & 0xff;
  2260.                   sp += 2;
  2261.                }
  2262.             }
  2263.             break;
  2264.          }
  2265.       }
  2266.    }
  2267. }
  2268. #endif
  2269.  
  2270. #if defined(PNG_READ_EXPAND_SUPPORTED)
  2271. /* expands a palette row to an rgb or rgba row depending
  2272.    upon whether you supply trans and num_trans */
  2273. void
  2274. png_do_expand_palette(png_row_info *row_info, png_byte *row,
  2275.    png_color *palette,
  2276.    png_byte *trans, int num_trans)
  2277. {
  2278.    if (row && row_info && row_info->color_type == PNG_COLOR_TYPE_PALETTE)
  2279.    {
  2280.       if (row_info->bit_depth < 8)
  2281.       {
  2282.          switch (row_info->bit_depth)
  2283.          {
  2284.             case 1:
  2285.             {
  2286.                png_byte *sp;
  2287.                png_byte *dp;
  2288.                int shift;
  2289.                png_uint_32 i;
  2290.  
  2291.                sp = row + (png_size_t)((row_info->width - 1) >> 3);
  2292.                dp = row + (png_size_t)row_info->width - 1;
  2293.                shift = 7 - (int)((row_info->width + 7) & 7);
  2294.                for (i = 0; i < row_info->width; i++)
  2295.                {
  2296.                   if ((*sp >> shift) & 0x1)
  2297.                      *dp = 1;
  2298.                   else
  2299.                      *dp = 0;
  2300.                   if (shift == 7)
  2301.                   {
  2302.                      shift = 0;
  2303.                      sp--;
  2304.                   }
  2305.                   else
  2306.                      shift++;
  2307.  
  2308.                   dp--;
  2309.                }
  2310.                break;
  2311.             }
  2312.             case 2:
  2313.             {
  2314.                png_byte *sp;
  2315.                png_byte *dp;
  2316.                int shift, value;
  2317.                png_uint_32 i;
  2318.  
  2319.                sp = row + (png_size_t)((row_info->width - 1) >> 2);
  2320.                dp = row + (png_size_t)row_info->width - 1;
  2321.                shift = (int)((3 - ((row_info->width + 3) & 3)) << 1);
  2322.                for (i = 0; i < row_info->width; i++)
  2323.                {
  2324.                   value = (*sp >> shift) & 0x3;
  2325.                   *dp = value;
  2326.                   if (shift == 6)
  2327.                   {
  2328.                      shift = 0;
  2329.                      sp--;
  2330.                   }
  2331.                   else
  2332.                      shift += 2;
  2333.  
  2334.                   dp--;
  2335.                }
  2336.                break;
  2337.             }
  2338.             case 4:
  2339.             {
  2340.                png_byte *sp;
  2341.                png_byte *dp;
  2342.                int shift, value;
  2343.                png_uint_32 i;
  2344.  
  2345.                sp = row + (png_size_t)((row_info->width - 1) >> 1);
  2346.                dp = row + (png_size_t)row_info->width - 1;
  2347.                shift = (int)((row_info->width & 1) << 2);
  2348.                for (i = 0; i < row_info->width; i++)
  2349.                {
  2350.                   value = (*sp >> shift) & 0xf;
  2351.                   *dp = value;
  2352.                   if (shift == 4)
  2353.                   {
  2354.                      shift = 0;
  2355.                      sp--;
  2356.                   }
  2357.                   else
  2358.                      shift += 4;
  2359.  
  2360.                   dp--;
  2361.                }
  2362.                break;
  2363.             }
  2364.          }
  2365.          row_info->bit_depth = 8;
  2366.          row_info->pixel_depth = 8;
  2367.          row_info->rowbytes = row_info->width;
  2368.       }
  2369.       switch (row_info->bit_depth)
  2370.       {
  2371.          case 8:
  2372.          {
  2373.             if (trans)
  2374.             {
  2375.                png_byte *sp, *dp;
  2376.                png_uint_32 i;
  2377.  
  2378.                sp = row + (png_size_t)row_info->width - 1;
  2379.                dp = row + (png_size_t)(row_info->width << 2) - 1;
  2380.  
  2381.                for (i = 0; i < row_info->width; i++)
  2382.                {
  2383.                   if (*sp >= (png_byte)num_trans)
  2384.                      *dp-- = 0xff;
  2385.                   else
  2386.                      *dp-- = trans[*sp];
  2387.                   *dp-- = palette[*sp].blue;
  2388.                   *dp-- = palette[*sp].green;
  2389.                   *dp-- = palette[*sp].red;
  2390.                   sp--;
  2391.                }
  2392.                row_info->bit_depth = 8;
  2393.                row_info->pixel_depth = 32;
  2394.                row_info->rowbytes = row_info->width * 4;
  2395.                row_info->color_type = 6;
  2396.                row_info->channels = 4;
  2397.             }
  2398.             else
  2399.             {
  2400.                png_byte *sp, *dp;
  2401.                png_uint_32 i;
  2402.  
  2403.                sp = row + (png_size_t)row_info->width - 1;
  2404.                dp = row + (png_size_t)(row_info->width * 3) - 1;
  2405.  
  2406.                for (i = 0; i < row_info->width; i++)
  2407.                {
  2408.                   *dp-- = palette[*sp].blue;
  2409.                   *dp-- = palette[*sp].green;
  2410.                   *dp-- = palette[*sp].red;
  2411.                   sp--;
  2412.                }
  2413.                row_info->bit_depth = 8;
  2414.                row_info->pixel_depth = 24;
  2415.                row_info->rowbytes = row_info->width * 3;
  2416.                row_info->color_type = 2;
  2417.                row_info->channels = 3;
  2418.             }
  2419.             break;
  2420.          }
  2421.       }
  2422.    }
  2423. }
  2424.  
  2425. /* if the bit depth < 8, it is expanded to 8.  Also, if the
  2426.    transparency value is supplied, an alpha channel is built. */
  2427. void
  2428. png_do_expand(png_row_info *row_info, png_byte *row,
  2429.    png_color_16 *trans_value)
  2430. {
  2431.    if (row && row_info)
  2432.    {
  2433.       if (row_info->color_type == PNG_COLOR_TYPE_GRAY &&
  2434.          row_info->bit_depth < 8)
  2435.       {
  2436.          switch (row_info->bit_depth)
  2437.          {
  2438.             case 1:
  2439.             {
  2440.                png_byte *sp;
  2441.                png_byte *dp;
  2442.                int shift;
  2443.                png_uint_32 i;
  2444.  
  2445.                sp = row + (png_size_t)((row_info->width - 1) >> 3);
  2446.                dp = row + (png_size_t)row_info->width - 1;
  2447.                shift = 7 - (int)((row_info->width + 7) & 7);
  2448.                for (i = 0; i < row_info->width; i++)
  2449.                {
  2450.                   if ((*sp >> shift) & 0x1)
  2451.                      *dp = 0xff;
  2452.                   else
  2453.                      *dp = 0;
  2454.                   if (shift == 7)
  2455.                   {
  2456.                      shift = 0;
  2457.                      sp--;
  2458.                   }
  2459.                   else
  2460.                      shift++;
  2461.  
  2462.                   dp--;
  2463.                }
  2464.                break;
  2465.             }
  2466.             case 2:
  2467.             {
  2468.                png_byte *sp;
  2469.                png_byte *dp;
  2470.                int shift, value;
  2471.                png_uint_32 i;
  2472.  
  2473.                sp = row + (png_size_t)((row_info->width - 1) >> 2);
  2474.                dp = row + (png_size_t)row_info->width - 1;
  2475.                shift = (int)((3 - ((row_info->width + 3) & 3)) << 1);
  2476.                for (i = 0; i < row_info->width; i++)
  2477.                {
  2478.                   value = (*sp >> shift) & 0x3;
  2479.                   *dp = (value | (value << 2) | (value << 4) |
  2480.                      (value << 6));
  2481.                   if (shift == 6)
  2482.                   {
  2483.                      shift = 0;
  2484.                      sp--;
  2485.                   }
  2486.                   else
  2487.                      shift += 2;
  2488.  
  2489.                   dp--;
  2490.                }
  2491.                break;
  2492.             }
  2493.             case 4:
  2494.             {
  2495.                png_byte *sp;
  2496.                png_byte *dp;
  2497.                int shift, value;
  2498.                png_uint_32 i;
  2499.  
  2500.                sp = row + (png_size_t)((row_info->width - 1) >> 1);
  2501.                dp = row + (png_size_t)row_info->width - 1;
  2502.                shift = (int)((1 - ((row_info->width + 1) & 1)) << 2);
  2503.                for (i = 0; i < row_info->width; i++)
  2504.                {
  2505.                   value = (*sp >> shift) & 0xf;
  2506.                   *dp = (value | (value << 4));
  2507.                   if (shift == 4)
  2508.                   {
  2509.                      shift = 0;
  2510.                      sp--;
  2511.                   }
  2512.                   else
  2513.                      shift = 4;
  2514.  
  2515.                   dp--;
  2516.                }
  2517.                break;
  2518.             }
  2519.          }
  2520.          row_info->bit_depth = 8;
  2521.          row_info->pixel_depth = 8;
  2522.          row_info->rowbytes = row_info->width;
  2523.       }
  2524.       if (row_info->color_type == PNG_COLOR_TYPE_GRAY && trans_value)
  2525.       {
  2526.          if (row_info->bit_depth == 8)
  2527.          {
  2528.             png_byte *sp, *dp;
  2529.             png_uint_32 i;
  2530.  
  2531.             sp = row + (png_size_t)row_info->width - 1;
  2532.             dp = row + (png_size_t)(row_info->width << 1) - 1;
  2533.             for (i = 0; i < row_info->width; i++)
  2534.             {
  2535.                if (*sp == trans_value->gray)
  2536.                   *dp-- = 0;
  2537.                else
  2538.                   *dp-- = 0xff;
  2539.                *dp-- = *sp--;
  2540.             }
  2541.          }
  2542.          else if (row_info->bit_depth == 16)
  2543.          {
  2544.             png_byte *sp, *dp;
  2545.             png_uint_32 i;
  2546.  
  2547.             sp = row + (png_size_t)row_info->rowbytes - 1;
  2548.             dp = row + (png_size_t)(row_info->rowbytes << 1) - 1;
  2549.             for (i = 0; i < row_info->width; i++)
  2550.             {
  2551.                if (((png_uint_16)*(sp) |
  2552.                   ((png_uint_16)*(sp - 1) << 8)) == trans_value->gray)
  2553.                {
  2554.                   *dp-- = 0;
  2555.                   *dp-- = 0;
  2556.                }
  2557.                else
  2558.                {
  2559.                   *dp-- = 0xff;
  2560.                   *dp-- = 0xff;
  2561.                }
  2562.                *dp-- = *sp--;
  2563.                *dp-- = *sp--;
  2564.             }
  2565.          }
  2566.          row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
  2567.          row_info->channels = 2;
  2568.          row_info->pixel_depth = (row_info->bit_depth << 1);
  2569.          row_info->rowbytes =
  2570.             ((row_info->width * row_info->pixel_depth) >> 3);
  2571.       }
  2572.       else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)
  2573.       {
  2574.          if (row_info->bit_depth == 8)
  2575.          {
  2576.             png_byte *sp, *dp;
  2577.             png_uint_32 i;
  2578.  
  2579.             sp = row + (png_size_t)row_info->rowbytes - 1;
  2580.             dp = row + (png_size_t)(row_info->width << 2) - 1;
  2581.             for (i = 0; i < row_info->width; i++)
  2582.             {
  2583.                if (*(sp - 2) == trans_value->red &&
  2584.                   *(sp - 1) == trans_value->green &&
  2585.                   *(sp - 0) == trans_value->blue)
  2586.                   *dp-- = 0;
  2587.                else
  2588.                   *dp-- = 0xff;
  2589.                *dp-- = *sp--;
  2590.                *dp-- = *sp--;
  2591.                *dp-- = *sp--;
  2592.             }
  2593.          }
  2594.          else if (row_info->bit_depth == 16)
  2595.          {
  2596.             png_byte *sp, *dp;
  2597.             png_uint_32 i;
  2598.  
  2599.             sp = row + (png_size_t)row_info->rowbytes - 1;
  2600.             dp = row + (png_size_t)(row_info->width << 3) - 1;
  2601.             for (i = 0; i < row_info->width; i++)
  2602.             {
  2603.                if ((((png_uint_16)*(sp - 4) |
  2604.                   ((png_uint_16)*(sp - 5) << 8)) == trans_value->red) &&
  2605.                   (((png_uint_16)*(sp - 2) |
  2606.                   ((png_uint_16)*(sp - 3) << 8)) == trans_value->green) &&
  2607.                   (((png_uint_16)*(sp - 0) |
  2608.                   ((png_uint_16)*(sp - 1) << 8)) == trans_value->blue))
  2609.                {
  2610.                   *dp-- = 0;
  2611.                   *dp-- = 0;
  2612.                }
  2613.                else
  2614.                {
  2615.                   *dp-- = 0xff;
  2616.                   *dp-- = 0xff;
  2617.                }
  2618.                *dp-- = *sp--;
  2619.                *dp-- = *sp--;
  2620.                *dp-- = *sp--;
  2621.                *dp-- = *sp--;
  2622.                *dp-- = *sp--;
  2623.                *dp-- = *sp--;
  2624.             }
  2625.          }
  2626.          row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
  2627.          row_info->channels = 4;
  2628.          row_info->pixel_depth = (row_info->bit_depth << 2);
  2629.          row_info->rowbytes =
  2630.             ((row_info->width * row_info->pixel_depth) >> 3);
  2631.       }
  2632.    }
  2633. }
  2634. #endif
  2635.  
  2636. #if defined(PNG_READ_DITHER_SUPPORTED)
  2637. void
  2638. png_do_dither(png_row_info *row_info, png_byte *row,
  2639.    png_byte *palette_lookup, png_byte *dither_lookup)
  2640. {
  2641.    if (row && row_info)
  2642.    {
  2643.       if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
  2644.          palette_lookup && row_info->bit_depth == 8)
  2645.       {
  2646.          int r, g, b, p;
  2647.          png_byte *sp, *dp;
  2648.          png_uint_32 i;
  2649.  
  2650.          sp = row;
  2651.          dp = row;
  2652.          for (i = 0; i < row_info->width; i++)
  2653.          {
  2654.             r = *sp++;
  2655.             g = *sp++;
  2656.             b = *sp++;
  2657.  
  2658.             /* this looks real messy, but the compiler will reduce
  2659.                it down to a reasonable formula.  For example, with
  2660.                5 bits per color, we get:
  2661.                p = (((r >> 3) & 0x1f) << 10) |
  2662.                   (((g >> 3) & 0x1f) << 5) |
  2663.                   ((b >> 3) & 0x1f);
  2664.                */
  2665.             p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
  2666.                ((1 << PNG_DITHER_RED_BITS) - 1)) <<
  2667.                (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
  2668.                (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
  2669.                ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
  2670.                (PNG_DITHER_BLUE_BITS)) |
  2671.                ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
  2672.                ((1 << PNG_DITHER_BLUE_BITS) - 1));
  2673.  
  2674.             *dp++ = palette_lookup[p];
  2675.          }
  2676.          row_info->color_type = PNG_COLOR_TYPE_PALETTE;
  2677.          row_info->channels = 1;
  2678.          row_info->pixel_depth = row_info->bit_depth;
  2679.          row_info->rowbytes =
  2680.             ((row_info->width * row_info->pixel_depth + 7) >> 3);
  2681.       }
  2682.       else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
  2683.          palette_lookup && row_info->bit_depth == 8)
  2684.       {
  2685.          int r, g, b, p;
  2686.          png_byte *sp, *dp;
  2687.          png_uint_32 i;
  2688.  
  2689.          sp = row;
  2690.          dp = row;
  2691.          for (i = 0; i < row_info->width; i++)
  2692.          {
  2693.             r = *sp++;
  2694.             g = *sp++;
  2695.             b = *sp++;
  2696.             sp++;
  2697.  
  2698.             p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
  2699.                ((1 << PNG_DITHER_RED_BITS) - 1)) <<
  2700.                (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
  2701.                (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
  2702.                ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
  2703.                (PNG_DITHER_BLUE_BITS)) |
  2704.                ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
  2705.                ((1 << PNG_DITHER_BLUE_BITS) - 1));
  2706.  
  2707.             *dp++ = palette_lookup[p];
  2708.          }
  2709.          row_info->color_type = PNG_COLOR_TYPE_PALETTE;
  2710.          row_info->channels = 1;
  2711.          row_info->pixel_depth = row_info->bit_depth;
  2712.          row_info->rowbytes =
  2713.             ((row_info->width * row_info->pixel_depth + 7) >> 3);
  2714.       }
  2715.       else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
  2716.          dither_lookup && row_info->bit_depth == 8)
  2717.       {
  2718.          png_byte *sp;
  2719.          png_uint_32 i;
  2720.  
  2721.          sp = row;
  2722.          for (i = 0; i < row_info->width; i++, sp++)
  2723.          {
  2724.             *sp = dither_lookup[*sp];
  2725.          }
  2726.       }
  2727.    }
  2728. }
  2729. #endif
  2730.  
  2731. #if defined(PNG_READ_GAMMA_SUPPORTED)
  2732. static int png_gamma_shift[] =
  2733.    {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0};
  2734.  
  2735. void
  2736. png_build_gamma_table(png_struct *png_ptr)
  2737. {
  2738.    if (png_ptr->bit_depth <= 8)
  2739.    {
  2740.       int i;
  2741.       double g;
  2742.  
  2743.       g = 1.0 / (png_ptr->gamma * png_ptr->display_gamma);
  2744.  
  2745.       png_ptr->gamma_table = (png_byte *)png_malloc(png_ptr,
  2746.          (png_uint_32)256);
  2747.  
  2748.       for (i = 0; i < 256; i++)
  2749.       {
  2750.          png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,
  2751.             g) * 255.0 + .5);
  2752.       }
  2753.  
  2754.       if (png_ptr->transformations & PNG_BACKGROUND)
  2755.       {
  2756.          g = 1.0 / (png_ptr->gamma);
  2757.  
  2758.          png_ptr->gamma_to_1 = (png_byte *)png_malloc(png_ptr,
  2759.             (png_uint_32)256);
  2760.  
  2761.          for (i = 0; i < 256; i++)
  2762.          {
  2763.             png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,
  2764.                g) * 255.0 + .5);
  2765.          }
  2766.  
  2767.          g = 1.0 / (png_ptr->display_gamma);
  2768.  
  2769.          png_ptr->gamma_from_1 = (png_byte *)png_malloc(png_ptr,
  2770.             (png_uint_32)256);
  2771.  
  2772.          for (i = 0; i < 256; i++)
  2773.          {
  2774.             png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,
  2775.                g) * 255.0 + .5);
  2776.          }
  2777.       }
  2778.    }
  2779.    else
  2780.    {
  2781.       double g;
  2782.       int i, j, shift, num;
  2783.       int sig_bit;
  2784.       png_uint_32 ig;
  2785.  
  2786.       if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
  2787.       {
  2788.          sig_bit = (int)png_ptr->sig_bit.red;
  2789.          if ((int)png_ptr->sig_bit.green > sig_bit)
  2790.             sig_bit = png_ptr->sig_bit.green;
  2791.          if ((int)png_ptr->sig_bit.blue > sig_bit)
  2792.             sig_bit = png_ptr->sig_bit.blue;
  2793.       }
  2794.       else
  2795.       {
  2796.          sig_bit = (int)png_ptr->sig_bit.gray;
  2797.       }
  2798.  
  2799.       if (sig_bit > 0)
  2800.          shift = 16 - sig_bit;
  2801.       else
  2802.          shift = 0;
  2803.  
  2804.       if (png_ptr->transformations & PNG_16_TO_8)
  2805.       {
  2806.          if (shift < (16 - PNG_MAX_GAMMA_8))
  2807.             shift = (16 - PNG_MAX_GAMMA_8);
  2808.       }
  2809.  
  2810.       if (shift > 8)
  2811.          shift = 8;
  2812.       if (shift < 0)
  2813.          shift = 0;
  2814.  
  2815.       png_ptr->gamma_shift = shift;
  2816.  
  2817.       num = (1 << (8 - shift));
  2818.  
  2819.       g = 1.0 / (png_ptr->gamma * png_ptr->display_gamma);
  2820.  
  2821.       png_ptr->gamma_16_table = (png_uint_16 **)png_malloc(png_ptr,
  2822.          num * sizeof (png_uint_16 *));
  2823.  
  2824.       if ((png_ptr->transformations & PNG_16_TO_8) &&
  2825.          !(png_ptr->transformations & PNG_BACKGROUND))
  2826.       {
  2827.          double fin, fout;
  2828.          png_uint_32 last, max;
  2829.  
  2830.          for (i = 0; i < num; i++)
  2831.          {
  2832.             png_ptr->gamma_16_table[i] = (png_uint_16 *)png_malloc(png_ptr,
  2833.                256 * sizeof (png_uint_16));
  2834.          }
  2835.  
  2836.          g = 1.0 / g;
  2837.           last = 0;
  2838.           for (i = 0; i < 256; i++)
  2839.          {
  2840.               fout = ((double)i + 0.5) / 256.0;
  2841.               fin = pow(fout, g);
  2842.               max = (png_uint_32)(fin * (double)(num << 8));
  2843.               while (last <= max)
  2844.             {
  2845.                   png_ptr->gamma_16_table[(int)(last >> 8)]
  2846.                   [(int)(last & 0xff)] =
  2847.                   (png_uint_16)i | ((png_uint_16)i << 8);
  2848.                last++;
  2849.             }
  2850.           }
  2851.           while (last < (num << 8))
  2852.          {
  2853.               png_ptr->gamma_16_table[(int)(last >> 8)][(int)(last & 0xff)] =
  2854.                (png_uint_16)65535L;
  2855.             last++;
  2856.          }
  2857.       }
  2858.       else
  2859.       {
  2860.          for (i = 0; i < num; i++)
  2861.          {
  2862.             png_ptr->gamma_16_table[i] = (png_uint_16 *)png_malloc(png_ptr,
  2863.                256 * sizeof (png_uint_16));
  2864.  
  2865.             ig = (((png_uint_32)i *
  2866.                (png_uint_32)png_gamma_shift[shift]) >> 4);
  2867.             for (j = 0; j < 256; j++)
  2868.             {
  2869.                png_ptr->gamma_16_table[i][j] =
  2870.                   (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
  2871.                      65535.0, g) * 65535.0 + .5);
  2872.             }
  2873.          }
  2874.       }
  2875.  
  2876.       if (png_ptr->transformations & PNG_BACKGROUND)
  2877.       {
  2878.          g = 1.0 / (png_ptr->gamma);
  2879.  
  2880.          png_ptr->gamma_16_to_1 = (png_uint_16 **)png_malloc(png_ptr,
  2881.             num * sizeof (png_uint_16 *));
  2882.  
  2883.          for (i = 0; i < num; i++)
  2884.          {
  2885.             png_ptr->gamma_16_to_1[i] = (png_uint_16 *)png_malloc(png_ptr,
  2886.                256 * sizeof (png_uint_16));
  2887.  
  2888.             ig = (((png_uint_32)i *
  2889.                (png_uint_32)png_gamma_shift[shift]) >> 4);
  2890.             for (j = 0; j < 256; j++)
  2891.             {
  2892.                png_ptr->gamma_16_to_1[i][j] =
  2893.                   (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
  2894.                      65535.0, g) * 65535.0 + .5);
  2895.             }
  2896.          }
  2897.          g = 1.0 / (png_ptr->display_gamma);
  2898.  
  2899.          png_ptr->gamma_16_from_1 = (png_uint_16 **)png_malloc(png_ptr,
  2900.             num * sizeof (png_uint_16 *));
  2901.  
  2902.          for (i = 0; i < num; i++)
  2903.          {
  2904.             png_ptr->gamma_16_from_1[i] = (png_uint_16 *)png_malloc(png_ptr,
  2905.                256 * sizeof (png_uint_16));
  2906.  
  2907.             ig = (((png_uint_32)i *
  2908.                (png_uint_32)png_gamma_shift[shift]) >> 4);
  2909.             for (j = 0; j < 256; j++)
  2910.             {
  2911.                png_ptr->gamma_16_from_1[i][j] =
  2912.                   (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
  2913.                      65535.0, g) * 65535.0 + .5);
  2914.             }
  2915.          }
  2916.       }
  2917.    }
  2918. }
  2919. #endif
  2920.  
  2921.